For any 4-digit integer except the ones with all the digits being the same, if we sort the digits in non-increasing order first, and then in non-decreasing order, a new number can be obtained by taking the second number from the first one. Repeat in this manner we will soon end up at the number 6174 -- the "black hole" of 4-digit numbers. This number is named Kaprekar Constant.

For example, start from 6767, we‘ll get:

7766 - 6677 = 1089
9810 - 0189 = 9621
9621 - 1269 = 8352
8532 - 2358 = 6174
7641 - 1467 = 6174
... ...

Given any 4-digit number, you are supposed to illustrate the way it gets into the black hole.

Input Specification:

Each input file contains one test case which gives a positive integer N in the range (0, 10000).

Output Specification:

If all the 4 digits of N are the same, print in one line the equation "N - N = 0000". Else print each step of calculation in a line until 6174 comes out as the difference. All the numbers must be printed as 4-digit numbers.

6767

7766 - 6677 = 1089
9810 - 0189 = 9621
9621 - 1269 = 8352
8532 - 2358 = 6174

2222

2222 - 2222 = 0000

Mooncake is a Chinese bakery product traditionally eaten during the Mid-Autumn Festival. Many types of fillings and crusts can be found in traditional mooncakes according to the region‘s culture. Now given the inventory amounts and the prices of all kinds of the mooncakes, together with the maximum total demand of the market, you are supposed to tell the maximum profit that can be made.

Note: partial inventory storage can be taken. The sample shows the following situation: given three kinds of mooncakes with inventory amounts being 180, 150, and 100 thousand tons, and the prices being 7.5, 7.2, and 4.5 billion yuans. If the market demand can be at most 200 thousand tons, the best we can do is to sell 150 thousand tons of the second kind of mooncake, and 50 thousand tons of the third kind. Hence the total profit is 7.2 + 4.5/2 = 9.45 (billion yuans).

Input Specification:

Each input file contains one test case. For each case, the first line contains 2 positive integers N (<=1000), the number of different kinds of mooncakes, and D (<=500 thousand tons), the maximum total demand of the market. Then the second line gives the positive inventory amounts (in thousand tons), and the third line gives the positive prices (in billion yuans) of N kinds of mooncakes. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print the maximum profit (in billion yuans) in one line, accurate up to 2 decimal places.

3 200
180 150 100
7.5 7.2 4.5

9.45

//1070 
//Greedy
#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;

struct mooncake {
  double quantity;
  double profits;
  double s_pro;
};

bool cmp(mooncake a, mooncake b)
{
  return a.s_pro > b.s_pro;
}

int main()
{
  int N;
  double D;
  scanf("%d %lf", &N, &D);

  vector<mooncake> mooncakes(N);
  int i;
  for(i = 0; i < N; i++)
  {
    double q;
    scanf("%lf", &q);
    mooncakes[i].quantity = q;
  }
  for(i = 0; i < N; i++)
  {
    double p;
    scanf("%lf", &p);
    mooncakes[i].profits = p;
  
    mooncakes[i].s_pro = mooncakes[i].profits/mooncakes[i].quantity;
  }

  sort(mooncakes.begin(), mooncakes.end(), cmp);

  double sum = D;
  i = 0;
  double profit = 0;
  while(i < mooncakes.size() && sum > 0)
  {
    int cos;
    if(sum > mooncakes[i].quantity)
      cos = mooncakes[i].quantity;
    else
      cos = sum;
    sum = sum - cos;
    profit += mooncakes[i].profits * cos / mooncakes[i].quantity;
    i++;
  }

  printf("%.2lf\n", profit);
  return 0;
}

Can1: "Can a can can a can?  It can!"

can 5

//1071
#include <cstring>
#include <cstdio>
#include <string>
#include <iostream>
#include <algorithm>
#include<map>
#include <vector>
#include <iterator>
using namespace std;

map<string, int> mp;

int main()
{
  char c;
  string str;
  vector<string> aux;
  int start = 0;

  while((c = getchar()) != '\n')
    str.push_back(c);
  
  string temp;
  int i = 0,  max_t = 0;
  while(i < str.size())
  {
    c = str[i];
    if(isalpha(c))
      temp.push_back(tolower(c));
    else if(isdigit(c))
      temp.push_back(c);
    else
    {
      if(!temp.empty())
      {
        int count = (++mp[temp]);
        if(max_t < count)
          max_t = count;
        temp.clear();
      }
    }
    i++;
  }
  
  if(!temp.empty())
  {
    int count = (++mp[temp]);
    if(max_t < count)
      max_t = count;
  }

  map<string, int>::iterator iter;

  for(iter=mp.begin(); iter!=mp.end(); iter++)
  {
    if(max_t == iter->second)
      break;
  }

  cout<< iter->first<<" "<< max_t<< endl;
  return 0;
}

A gas station has to be built at such a location that the minimum distance between the station and any of the residential housing is as far away as possible. However it must guarantee that all the houses are in its service range.

Now given the map of the city and several candidate locations for the gas station, you are supposed to give the best recommendation. If there are more than one solution, output the one with the smallest average distance to all the houses. If such a solution is still not unique, output the one with the smallest index number.

Input Specification:

Each input file contains one test case. For each case, the first line contains 4 positive integers: N (<= 10³), the total number of houses; M (<= 10), the total number of the candidate locations for the gas stations; K (<= 10⁴), the number of roads connecting the houses and the gas stations; and D_S, the maximum service range of the gas station. It is hence assumed that all the houses are numbered from 1 to N, and all the candidate locations are numbered from G1 to GM.

Then K lines follow, each describes a road in the format
P1 P2 Dist
where P1 and P2 are the two ends of a road which can be either house numbers or gas station numbers, and Dist is the integer length of the road.

Output Specification:

For each test case, print in the first line the index number of the best location. In the next line, print the minimum and the average distances between the solution and all the houses. The numbers in a line must be separated by a space and be accurate up to 1 decimal place. If the solution does not exist, simply output “No Solution”.

4 3 11 5
1 2 2
1 4 2
1 G1 4
1 G2 3
2 3 2
2 G2 1
3 4 2
3 G3 2
4 G1 3
G2 G1 1
G3 G2 2

G1
2.0 3.3

2 1 2 10
1 G1 9
2 G1 20

No Solution

版权声明：本文为博主原创文章，未经博主允许不得转载。