 people类重载“==”运算符和“=”运算符，

#include
using namespace std;class People{
public:
bool operator ==(People &a,People &b){
if(a.id==b.id)
cout<<"两个people对象的id相同"<<endl;
else
cout<<"两个people对象的id不同"<<endl;
}
void operator =(People &a,People &b){
a=b;
}
input();
output(){
cout<<"输出人员信息："<<endl;
cout<<"编号:"<<number<<endl<<"性别:"<<sex<<endl;
cout<<"出生日期:"<<birthday<<endl<<"身份证号:"<<id<<endl<<endl;
}private:
double number;
char sex[10];
char birthday[20];
double id;
};
People::input(){
cout<<"录入people信息"< cout cin>>number;cout<<"性别:"; cin>>sex; cout<<"出生日期:"; cin>>birthday; cout<<"身份证号:"; cin>>id; cout<<endl;
}
int main(int argc,char *argv[]){
People p1,p2;
p1.input();
p2.input();
People::operator ==(p1,p2);
People::operator =(p1,p2);
cout<<"将p2赋给p1:"<<endl;
p1.output();
system("pause");
return 0;
}
重载=或者==只能有一个参数，应为类自身默认作为一个参数传进来，用this进行表示的。
重载=或者==只能有一个参数，应为类自身默认作为一个参数传进来，用this进行表示的。
 其他相关推荐
 Food 程序设计
 Problem Description You, a parttime dining service worker in your college’s dining hall, are now confused with a new problem: serve as many people as possible. The issue comes up as people in your college are more and more difficult to serve with meal: They eat only some certain kinds of food and drink, and with requirement unsatisfied, go away directly. You have prepared F (1 <= F <= 200) kinds of food and D (1 <= D <= 200) kinds of drink. Each kind of food or drink has certain amount, that is, how many people could this food or drink serve. Besides, You know there’re N (1 <= N <= 200) people and you too can tell people’s personal preference for food and drink. Back to your goal: to serve as many people as possible. So you must decide a plan where some people are served while requirements of the rest of them are unmet. You should notice that, when one’s requirement is unmet, he/she would just go away, refusing any service. Input There are several test cases. For each test case, the first line contains three numbers: N,F,D, denoting the number of people, food, and drink. The second line contains F integers, the ith number of which denotes amount of representative food. The third line contains D integers, the ith number of which denotes amount of representative drink. Following is N line, each consisting of a string of length F. e jth character in the ith one of these lines denotes whether people i would accept food j. “Y” for yes and “N” for no. Following is N line, each consisting of a string of length D. e jth character in the ith one of these lines denotes whether people i would accept drink j. “Y” for yes and “N” for no. Please process until EOF (End Of File). Output For each test case, please print a single line with one integer, the maximum number of people to be satisfied. Sample Input 4 3 3 1 1 1 1 1 1 YYN NYY YNY YNY YNY YYN YYN NNY Sample Output 3
 Groups 实现的问题
 Problem Description After the regional contest, all the ACMers are walking alone a very long avenue to the dining hall in groups. Groups can vary in size for kinds of reasons, which means, several players could walk together, forming a group. As the leader of the volunteers, you want to know where each player is. So you call every player on the road, and get the reply like “Well, there are Ai players in front of our group, as well as Bi players are following us.” from the ith player. You may assume that only N players walk in their way, and you get N information, one from each player. When you collected all the information, you found that you’re provided with wrong information. You would like to figure out, in the best situation, the number of people who provide correct information. By saying “the best situation” we mean as many people as possible are providing correct information. Input There’re several test cases. In each test case, the first line contains a single integer N (1 <= N <= 500) denoting the number of players along the avenue. The following N lines specify the players. Each of them contains two integers Ai and Bi (0 <= Ai,Bi < N) separated by single spaces. Please process until EOF (End Of File). Output For each test case your program should output a single integer M, the maximum number of players providing correct information. Sample Input 3 2 0 0 2 2 2 3 2 0 0 2 2 2 Sample Output 2 2
 Science! 科学的问题
 Problem Description Welcome, ladies and gentlemen, to Aperture Science. Astronauts, War Heroes, Olympians — you’re here because we want the best, and you are it. That said, it’s time to make some science. Now, I want each of you to stand on one of these buttons. Well done, we’re making great progress here. Now let’s do it again. Oh, come on  don’t stand on the same button! Move, people! No, no, that button’s only for the Astronauts, you know who you are. What?! You say you can’t do everything I ask? Ok let’s start over. You there, the Programmer, figure out how many times we can do this. And make it quick, we have a lot more science to get through… Input There will be several test cases in the input. The first line of each case will contain n (2≤n≤80) giving the number of people (and the number of buttons) in the experiment. The next n lines will contain n characters each. If the jth character of the ith line is Y it indicates that the ith person can stand on the jth button (it is N otherwise). The last line of input will be a 0. Output For each test case, output k, the maximum number of times everyone can be standing on buttons such that nobody stands on the same button more than once (This might be 0). After that, output k lines. Each line should contain n integers separated by single spaces, where the ith integer describes which person is standing on the ith button. All of the lines should be valid and none of them should put the same person on the same button as a previous line of the same test case. Output no extra spaces, and do not separate answers with blank lines. Note that correct outputs might not be unique. Sample Input 3 YYY NYY YNY 2 YN YN 0 Sample Output 2 3 1 2 1 2 3 0
 Find Black Hand 的问题
 Problem Description I like playing game with my friends, although sometimes look pretty naive. Today I invent a new game called find black hand. The game is not about catching bad people but playing on a string. Now I generate a string S and several short ones s[i], and I define three kinds of operations. 1. Delete: remove the ith character. 2. Insert: in any position, insert a character if you like. 3. Change: change the ith character into another character if you like. For each short string s[i], we define a function f(i). After several operations on S, we can find a substring of S which is the same to s[i]. And f(i) is the minimal number of operations to achieve. It looks so native that I think every one of you can solve f(i) perfectly. So I join the string S from end to end, and f(i) changes nothing. So the string "bb" is also a substring of string "baaab". The "black hand" is the short string s[i] whose f(i) is minimal. Now it's your time to find the black hand. Input There are multiple test cases. The first line contains a nonempty string S whose length is not more than 100,000. The next line contains an integer N (1 <= N <= 10) indicating the number of the short string. Each of the next N lines contains a short nonempty string whose length is not more than 10. All strings in the input would not have blank and all characters are lower case. Output For each test case, output a string first indicating the "black hand", and then output an integer indicating the minimal number of the operation. If there are more than one "black hand", please output the smallest one in lexicographical order. Sample Input aaabbbb 2 alice bob Sample Output bob 1
 Two Famous Companies 程序的思路
 Problem Description In China, there are two companies offering the Internet service for the people from all cities: China Telecom and China Unicom. They both are planning to build cables between cities. Obviously, the government wants to connect all the cities in minimum costs. So the minister of finance Mr. B wants to choose some of the cable plans from the two companies and calculate the minimum cost needed to connect all the cities. Mr. B knows that N1 cables should be built in order to connect all N cities of China. For some honorable reason, Mr. B should choose K cables from the China Telecom and the rest N1K cables from the China Unicom. Your job is to help Mr. B determine which cables should be built and the minimum cost to build them. You may assume that the solution always exists. Input Each test case starts with a line containing the number of cities N (1 <= N <= 50,000), number of cable plans M (N1 <= M <= 100,000) and the number of required cables from China Telecom K (0 <= K <= N1). This is followed by M lines, each containing four integers a, b, c, x (0 <= a, b <= N1, a != b, 1 <= c <= 100, x in {0,1} indicating the pair of cities this cable will connect, the cost to build this cable and the company this cable plan belongs to. x=0 denotes that the cable plan belongs to China Telecom and x=1 denotes that the cable plan is from China Unicom. Output For each test case, display the case number and the minimum cost of the cable building. Sample Input 2 2 1 0 1 1 1 0 1 2 0 2 2 0 0 1 1 1 0 1 2 0 Sample Output Case 1: 2 Case 2: 1
 Treasure Map 地图
 Problem Description "Take 147 steps due north, turn 63 degrees clockwise, take 82 steps, ...". Most people don't realize how important accuracy is when following the directions on a pirate's treasure map. If you're even a tiny bit off at the start, you'll end up far away from the correct location at the end. Pirates therefore use very exact definitions. One step, for instance, has been defined by the 1670 Pirate Convention to be exactly two times the size of the wooden leg of Long John Silver, or 1.183 m in metricunits. Captain Borbassa was thus not at all worried when he set sail to the treasure island, having a rope with knots in it, exactly one step apart, for accurately measuring distances. Of course he also brought his good old geotriangle, once given to him by his father when he was six years old. However, on closer inspection of the map, he got an unpleasant surprise. The map was made by the famous captain Jack Magpie, who was notorious for including little gems into his directions.In this case, there were distances listed such as sqrt(33) steps. How do you measure that accurately? Fortunately, his first mate Pythagor came to the rescue. After puzzling for a few hours, he came up with the following solution: let pirate A go 4 steps into the perpendicular direction, and hold one end of the measuring rope there. Then pirate B goes into the desired direction while letting the rope slide through his fingers, until he is exactly 7 steps away from pirate A. Pythagor worked out a formula that states that pirate B has then traveled exactly sqrt(33) steps. Captain Borbassa was impressed, but he revealed that there were more such distances on the map. Paranoid as he is, he refuses to let Pythagor see the map, or even tell him what other distances there are on it. They are all square roots of integers, that's all he gets to know. Only on the island itself will the captain reveal the numbers, and then he expects Pyhtagor to quickly work out the smallest two integer numbers of steps that can combine to create the desired distance, using the method described above. Pythagor knows this is not easy, so he has asked your help. Can you help him by writing a program that can determine these two integers quickly? By the way, he did ask the captain how large the numbers inside the square root could get, and the captain replied "one billion". He was probably exaggerating, but you'd better make sure the program works. If you can successfully help the pirates, you'll get a share of the treasure. It might be gold, it might be silver, or it might even be... a treasure map! Input The first line of the input contains a single number: the number of test cases to follow. Each test case has the following format: 1.One line with one integer N, satisfying 1 <= N <= 10^9. Output For every test case in the input, the output should contain two nonnegative integers, separated by a space, on a single line: the distance pirate A needs to head in the perpendicular direction, and the final distance between pirate A and B, such that pirate B has traveled sqrt(N) steps. If there are multiple solutions, give the one with the smallest numbers. If there are no solutions, the output should be "IMPOSSIBLE" (without the quotation marks) on a single line. Sample Input 4 33 16 50 101 Sample Output 4 7 0 4 IMPOSSIBLE 50 51
 Burnout 程序怎么来写
 Problem Description Whenever you buy a light bulb, the package will state an amount of time that the bulb should last. But, that's assuming the bulb is on continuously. Most people turn their light bulbs on and off. How does this affect their lifetime? A friend of yours has built a rig to test this. Given a simple pattern, his rig will turn the bulb on and off, and a light sensor will tell when the bulb burns out. The pattern has a very simple syntax. It consists of a list of elements, separated by spaces. Each element is either a number M (1 ≤ M ≤ 1,000,000), indicating a number of milliseconds, or a repeating list. A repeating list consists of one or more elements, surrounded by parentheses, and followed by a ‘*’ and then an integer K (1 ≤ K ≤ 100). This integer K indicates how many times the list should be repeated. Your friend’s machine always starts with the bulb on, and then goes through the pattern. For every integer, it waits that number of milliseconds, and then switches the bulb. If the bulb is on, it's turned off, and if it's off, it gets turned back on. If the machine reaches the end of the pattern, it will start again from the beginning. For example, with this pattern: 1 3 5 The machine will start by turning the bulb on. It will wait 1 millisecond and turn the bulb off. It will then wait 3 milliseconds and turn the bulb on. It will then wait 5 milliseconds and turn the bulb off. It will then wait 1 millisecond and turn the bulb on. It will then wait 3 milliseconds and turn the bulb off. It will continue like this until the bulb burns out. Here's an example of a pattern with a repeating section: 1 (3 5)*2 7 The machine will start by turning the bulb on, and will change the bulb’s state after 1 millisecond, then 3, then 5, then 3, then 5, then 7, then 1..... Note that repeating sections can be nested inside of repeating sections. Your friend is not good with programming, though, so he's asked you to help. He can easily measure how long it takes for the bulb to actually burn out  but, how long SHOULD it have taken? Assume that turning the bulb on and off does NOT affect its life. Also assume that changing the bulb’s state takes no time. Given a life N in milliseconds, and a pattern of turning the bulb on and off, how many actual milliseconds would elapse before the bulb is on for exactly N milliseconds? Input There will be several test cases in the input. Each test case will consist of two lines. The first line will contain an integer N (1 ≤ N ≤ 1,000,000,000) which is the expected life of the bulb in milliseconds. The second line will contain a string, which is the pattern. The pattern will not be longer than 500 characters. The pattern consists of a list of elements, separated by single spaces. Each element is either a number M (1 ≤ M ≤ 1,000,000), indicating a number of milliseconds, or a repeating list. A repeating list consists of one or more elements, surrounded by parentheses, and followed by a ‘*’ and then an integer K (1 ≤ K ≤ 100). There will be single spaces separating elements of a list, but nowhere else. In particular, note that there will not be any spaces surrounding the ‘*’ at the end of a repeating list, nor immediately following an opening parenthesis, nor immediately before a closing parenthesis. The total amount of time represented by a pattern, including all repetition, will be no greater than 1,000,000,000. The input will terminate with a line with a single 0. Output For each test case, output a single integer on its own line, indicating the number of milliseconds of total elapsed time until the bulb has been lit for N milliseconds. Output no extra spaces, and do not separate answers with blank lines. Sample Input 100 20 30 40 1000 1 3 5 1000 1 (3 (5)*3 2)*2 7 0 Sample Output 190 1999 2279
 Family Fortune
 Problem Description While studying the history of wealthy families, researchers want to know just how much of a fortune each family has amassed. There are various 'net worth' figures for each individual throughout history, but totaling them is complicated by double counting, caused by inheritance. One way to estimate the wealth of a family is to sum up the net worth of a set of K people such that no one in the set is an ancestor or a descendant of anyone else in the set. The wealth of the family is the maximum sum achievable over all such sets of K people. Since historical records contain only the net worth of male family members, the family tree is a simple tree in which every male has exactly one father and a nonnegative number of sons. Also, there is exactly one person who is an ancestor of all other family members. Given information about a family tree, what is the wealth of the family, by this measure? Input There will be several test cases in the input. Each test case will begin with two integers: N K Where N (1 ≤ N ≤ 100,000) is the total number of family members in the records, and K (1 ≤ K ≤ 1,000) is the size of the desired set of people. Each of the next N lines will hold two integers: P W Where P (0 ≤ P ≤ N) indicates the parent of that family member. The family members are numbered from 1 to N, with the parent and fortune of family member i appearing on the i^th line. There will be a single root, with P=0. The tree will not have a depth greater than 1,000, and, of course, it won’t have any cycles. W (1 ≤ W ≤ 1,000) is the wealth (in millions) of that family member. The input will end with a line with two 0s. Output For each test case, output a single integer on its own line, which is the maximum sum (in millions) of the fortunes of a set of K family members in the tree, where no member of the set is an ancestor or descendant of any other member of the set. If you cannot find K such nodes, then output 0. Output no extra spaces, and do not separate answers with blank lines. Sample Input 11 5 0 1 1 1 1 1 2 1 2 1 3 1 3 1 3 1 5 1 7 1 7 1 11 5 11 3 1 1 4 1 1 2 10 2 10 2 6 2 6 1 10 2 11 3 0 4 7 3 0 18 1 20 1 15 2 12 2 6 3 8 3 8 0 0 Sample Output 5 10 36
 Holiday's Accommodation 怎么编写呢
 Problem Description Nowadays, people have many ways to save money on accommodation when they are on vacation. One of these ways is exchanging houses with other people. Here is a group of N people who want to travel around the world. They live in different cities, so they can travel to some other people's city and use someone's house temporary. Now they want to make a plan that choose a destination for each person. There are 2 rules should be satisfied: 1. All the people should go to one of the other people's city. 2. Two of them never go to the same city, because they are not willing to share a house. They want to maximize the sum of all people's travel distance. The travel distance of a person is the distance between the city he lives in and the city he travels to. These N cities have N  1 highways connecting them. The travelers always choose the shortest path when traveling. Given the highways' information, it is your job to find the best plan, that maximum the total travel distance of all people. Input The first line of input contains one integer T(1 <= T <= 10), indicating the number of test cases. Each test case contains several lines. The first line contains an integer N(2 <= N <= 105), representing the number of cities. Then the followingN1 lines each contains three integersX, Y,Z(1 <= X, Y <= N, 1 <= Z <= 106), means that there is a highway between city X and city Y , and length of that highway. You can assume all the cities are connected and the highways are bidirectional. Output For each test case in the input, print one line: "Case #X: Y", where X is the test case number (starting with 1) and Y represents the largest total travel distance of all people. Sample Input 2 4 1 2 3 2 3 2 4 3 2 6 1 2 3 2 3 4 2 4 1 4 5 8 5 6 5 Sample Output Case #1: 18 Case #2: 62
 java程序编程：编写3个类
 People、Student和主类；People类中有2个成员变量name和age，2个方法setName和show方法；Student类是People类的子类，包含1个成员变量department和一个方法setDepartment；主类中要求创建Student对象，调用以上3个方法并给参数赋值。
 Graph Theory? 图的理论
 Problem Description In mathematics and computer science, graph theory is the study of graphs, mathematical structures used to model pairwise relations between objects from a certain collection. A graph is a collection of vertices and a collection of edges that connect pairs of vertices. Simple word, we have an undirected graph with weight on its edge, and we want to choose a key point on this graph, be careful, the key point can be not only on a vertex, but also on an edge. To make the problem more close to reality and easy to understand, imagine it’s a country where everybody wants to go aboard, say TC for example, and the key point is the only exit of this country to the outside colorful world. The N vertices can be treated as cities, M edges as roads. And if the key point is chosen, everyone in every city will choose a shortest path to the key point, and leave this country as if one second more will erase the purity and dignity. But one last thing, visa. To simplify the problem, we already change the ID order and only the last K vertices have a visa office. One may choose any of those cities to get a visa. Of course, they will choose a visacity to make the total length as short as possible. And now, we come back to handle the original problem, where should the key vertex be? There are also two viewpoints for judging where the most perfect place is. We use Di to record the minimum cost for people in city i to get a visa and reach the key point, and Pi people in this city. The first opinion claims the Max(Di * Pi) to be as small as possible, while the second claims the Sum(Di * Pi) to be as small as possible. Your task is to solve both of these requests. For each request, report the minimum value it claims, and then, report the place it can choose to achieve that value. If more than one such place, report INFINITE instead (you may assume the people in TC only know 0 and 1, other numbers are just infinite for them). If you need to report a chosen place for key point, report the first edge id (1based) the point appears, and then the distance between the point and the first vertex. For example, if there is only an edge <1, 2>, and the key point lies in vertex 1, report (1, 0.000). Input The first line contains a single integer T, indicating the number of test cases. Each test case includes three integers N, M, K. Then a line with N integers Pi follows. Then M lines following, each line contains three integers Ai, Bi, Ci, describing an undirected road. You can assume there is as least one path between any city pair. Technical Specification 1. 1 <= T <= 64 2. 1 <= K < N <= 32 3. 0 <= Pi <= 1024 4. N  1 <= M <= 512 5. 1 <= Ci <= 1024 6. 1 <= Ai, Bi <= N, Ai != Bi, no edge pair appears more than once. Output For each test case, output the case number in the first line. Then two lines, the first line describe the max request, and the second describe the sum request, as the format in the description. Separate them by exactly one space, print “INFINITE” without quote if needed, and round all the floating numbers to three fractional digits. Refer to the sample output for more details. Even more than one such place, you should report the minimum value it claims first. Sample Input 2 3 3 1 1 2 3 1 2 1 2 3 2 1 3 3 4 4 2 3 2 1 1 1 2 2 2 3 2 3 4 2 4 1 2 Sample Output Case 1: 4.000 2 2.000 7.000 2 2.000 Case 2: 7.200 3 1.600 16.000 3 2.000
 有抽象类和类的关系如图，按要求完成程序：
 有抽象类和类的关系如图，按要求完成程序： （1）根据关系图完成抽象类People和子类Student的定义。抽象类People中有抽象方法print；在子类中新增工号number，在构造方法中调用父类构造方法，并为新属性赋值；实现print方法用于按格式输出信息。 （2）定义Test类，在main方法中用户通过键盘输入数据，根据输入数据创建Student类的对象（自己的姓名，学号，年龄），调用print方法输出学生信息。
 Burnout 怎么写的
 Problem Description Whenever you buy a light bulb, the package will state an amount of time that the bulb should last. But, that's assuming the bulb is on continuously. Most people turn their light bulbs on and off. How does this affect their lifetime? A friend of yours has built a rig to test this. Given a simple pattern, his rig will turn the bulb on and off, and a light sensor will tell when the bulb burns out. The pattern has a very simple syntax. It consists of a list of elements, separated by spaces. Each element is either a number M (1 ≤ M ≤ 1,000,000), indicating a number of milliseconds, or a repeating list. A repeating list consists of one or more elements, surrounded by parentheses, and followed by a ‘*’ and then an integer K (1 ≤ K ≤ 100). This integer K indicates how many times the list should be repeated. Your friend’s machine always starts with the bulb on, and then goes through the pattern. For every integer, it waits that number of milliseconds, and then switches the bulb. If the bulb is on, it's turned off, and if it's off, it gets turned back on. If the machine reaches the end of the pattern, it will start again from the beginning. For example, with this pattern: 1 3 5 The machine will start by turning the bulb on. It will wait 1 millisecond and turn the bulb off. It will then wait 3 milliseconds and turn the bulb on. It will then wait 5 milliseconds and turn the bulb off. It will then wait 1 millisecond and turn the bulb on. It will then wait 3 milliseconds and turn the bulb off. It will continue like this until the bulb burns out. Here's an example of a pattern with a repeating section: 1 (3 5)*2 7 The machine will start by turning the bulb on, and will change the bulb’s state after 1 millisecond, then 3, then 5, then 3, then 5, then 7, then 1..... Note that repeating sections can be nested inside of repeating sections. Your friend is not good with programming, though, so he's asked you to help. He can easily measure how long it takes for the bulb to actually burn out  but, how long SHOULD it have taken? Assume that turning the bulb on and off does NOT affect its life. Also assume that changing the bulb’s state takes no time. Given a life N in milliseconds, and a pattern of turning the bulb on and off, how many actual milliseconds would elapse before the bulb is on for exactly N milliseconds? Input There will be several test cases in the input. Each test case will consist of two lines. The first line will contain an integer N (1 ≤ N ≤ 1,000,000,000) which is the expected life of the bulb in milliseconds. The second line will contain a string, which is the pattern. The pattern will not be longer than 500 characters. The pattern consists of a list of elements, separated by single spaces. Each element is either a number M (1 ≤ M ≤ 1,000,000), indicating a number of milliseconds, or a repeating list. A repeating list consists of one or more elements, surrounded by parentheses, and followed by a ‘*’ and then an integer K (1 ≤ K ≤ 100). There will be single spaces separating elements of a list, but nowhere else. In particular, note that there will not be any spaces surrounding the ‘*’ at the end of a repeating list, nor immediately following an opening parenthesis, nor immediately before a closing parenthesis. The total amount of time represented by a pattern, including all repetition, will be no greater than 1,000,000,000. The input will terminate with a line with a single 0. Output For each test case, output a single integer on its own line, indicating the number of milliseconds of total elapsed time until the bulb has been lit for N milliseconds. Output no extra spaces, and do not separate answers with blank lines. Sample Input 100 20 30 40 1000 1 3 5 1000 1 (3 (5)*3 2)*2 7 0 Sample Output 190 1999 2279
 Friendship 友谊的算法问题
 Description In modern society, each person has his own friends. Since all the people are very busy, they communicate with each other only by phone. You can assume that people A can keep in touch with people B, only if 1. A knows B's phone number, or 2. A knows people C's phone number and C can keep in touch with B. It's assured that if people A knows people B's number, B will also know A's number. Sometimes, someone may meet something bad which makes him lose touch with all the others. For example, he may lose his phone number book and change his phone number at the same time. In this problem, you will know the relations between every two among N people. To make it easy, we number these N people by 1,2,...,N. Given two special people with the number S and T, when some people meet bad things, S may lose touch with T. Your job is to compute the minimal number of people that can make this situation happen. It is supposed that bad thing will never happen on S or T. Input The first line of the input contains three integers N (2<=N<=200), S and T ( 1 <= S, T <= N , and S is not equal to T).Each of the following N lines contains N integers. If i knows j's number, then the jth number in the (i+1)th line will be 1, otherwise the number will be 0. You can assume that the number of 1s will not exceed 5000 in the input. Output If there is no way to make A lose touch with B, print "NO ANSWER!" in a single line. Otherwise, the first line contains a single number t, which is the minimal number you have got, and if t is not zero, the second line is needed, which contains t integers in ascending order that indicate the number of people who meet bad things. The integers are separated by a single space. If there is more than one solution, we give every solution a score, and output the solution with the minimal score. We can compute the score of a solution in the following way: assume a solution is A1, A2, ..., At (1 <= A1 < A2 <...< At <=N ), the score will be (A11)*N^t+(A21)*N^(t1)+...+(At1)*N. The input will assure that there won't be two solutions with the minimal score. Sample Input 3 1 3 1 1 0 1 1 1 0 1 1 Sample Output 1 2
 Eliminate the Conflict 冲突的排除
 Problem Description Conflicts are everywhere in the world, from the young to the elderly, from families to countries. Conflicts cause quarrels, fights or even wars. How wonderful the world will be if all conflicts can be eliminated. Edward contributes his lifetime to invent a 'Conflict Resolution Terminal' and he has finally succeeded. This magic item has the ability to eliminate all the conflicts. It works like this: If any two people have conflict, they should simply put their hands into the 'Conflict Resolution Terminal' (which is simply a plastic tube). Then they play 'Rock, Paper and Scissors' in it. After they have decided what they will play, the tube should be opened and no one will have the chance to change. Finally, the winner have the right to rule and the loser should obey it. Conflict Eliminated! But the game is not that fair, because people may be following some patterns when they play, and if the pattern is founded by others, the others will win definitely. Alice and Bob always have conflicts with each other so they use the 'Conflict Resolution Terminal' a lot. Sadly for Bob, Alice found his pattern and can predict how Bob plays precisely. She is very kind that doesn't want to take advantage of that. So she tells Bob about it and they come up with a new way of eliminate the conflict: They will play the 'Rock, Paper and Scissors' for N round. Bob will set up some restricts on Alice. But the restrict can only be in the form of "you must play the same (or different) on the ith and jth rounds". If Alice loses in any round or break any of the rules she loses, otherwise she wins. Will Alice have a chance to win? Input The first line contains an integer T(1 <= T <= 50), indicating the number of test cases. Each test case contains several lines. The first line contains two integers N,M(1 <= N <= 10000, 1 <= M <= 10000), representing how many round they will play and how many restricts are there for Alice. The next line contains N integers B1,B2, ...,BN, where Bi represents what item Bob will play in the ith round. 1 represents Rock, 2 represents Paper, 3 represents Scissors. The following M lines each contains three integers A,B,K(1 <= A,B <= N,K = 0 or 1) represent a restrict for Alice. If K equals 0, Alice must play the same on Ath and Bth round. If K equals 1, she must play different items on Ath and Bthround. Output For each test case in the input, print one line: "Case #X: Y", where X is the test case number (starting with 1) and Y is "yes" or "no" represents whether Alice has a chance to win. Sample Input 2 3 3 1 1 1 1 2 1 1 3 1 2 3 1 5 5 1 2 3 2 1 1 2 1 1 3 1 1 4 1 1 5 1 2 3 0 Sample Output Case #1: no Case #2: yes
 Building bridges 修桥的问题
 Problem Description Hululu and Cululu are two pacific ocean countries made up of many islands. These two country has so many years of friendship so they decide to build bridges to connect their islands. Now they want to build the first bridge to connect an island of Hululu and an island of Culuu . Their world can be considered as a matrix made up of three letters 'H','C' and 'O'.Every 'H' stands for an island of Hululu, every 'C' stands for an island of Cululu, and 'O' stands for the ocean. Here is a example: The coordinate of the upleft corner is (0,0), and the downright corner is (4, 3). The xdirection is horizontal, and the ydirection is vertical. There may be too many options of selecting two islands. To simplify the problem , they come up with some rules below: 1. The distance between the two islands must be as short as possible. If the two islands' coordinates are (x1,y1) and (x2,y2), the distance is x1x2+y1y2. 2. If there are more than one pair of islands satisfied the rule 1, choose the pair in which the Hululu island has the smallest x coordinate. If there are still more than one options, choose the Hululu island which has the smallest y coordinate. 3.After the Hululu island is decided, if there are multiple options for the Cululu island, also make the choice by rule 2. Please help their people to build the bridge. Input There are multiple test cases. In each test case, the first line contains two integers M and N, meaning that the matrix is M×N ( 2<=M,N <= 40). Next M lines stand for the matrix. Each line has N letters. The input ends with M = 0 and N = 0. It's guaranteed that there is a solution. Output For each test case, choose two islands, then print their coordinates in a line in following format: x1 y1 x2 y2 x1,y1 is the coordinate of Hululu island, x2 ,y2 is the coordinate of Cululu island. Sample Input 4 4 CHCH HCHC CCCO COHO 5 4 OHCH HCHC CCCO COHO HCHC 0 0 Sample Output 0 1 0 0 0 1 0 2
 编写程序来模拟计算器，运算符二义定义的解决，怎么采用C语言的程序的编写的过程的思想呢
 Problem Description The Advanced Calculator Machinery (ACM) is going to release a new series of calculators. Like it or not, as a member of ACM, you are asked to develop the software for the new calculator. Here is the detailed technical specification. The general usage of the calculator is that users input expressions, the calculator computes and displays the final result, or error messages if there is something wrong. The expression is in infix notation and the calculator supports following operators: People always make mistakes. When user inputs an invalid expression, the calculator should display an error message, telling user that error occurs. There are totally four possible errors: 1. Syntax error: Any kind of syntax error, such as missing operators, redundancy operators and unpaired brackets. 2. Divide by zero: The right operand of operator “/” or “%” is zero. 3. Integer overflow: At any step of the calculation, any intermediate values go beyond the range of 32bit signed integers. 4. Invalid exponent: The right operand of operator“^” is negative, or both operands are zero (we consider 0^0 undefined). The calculation works this way: at first the calculator omits all space characters of the expression, check the syntax, and then computes. It always finds the highest priority part of the expression, then operators which combines them, then calculate the result and continue the process, until the final result has been got or error occurs. For example, for expression 2^3^(4*5), there are mainly 5 steps (we use brackets to note every part of the expression): 1. Check the syntax, no syntax errors. 2. Fetch the highest priority operator 4, no errors. 3. Do arithmetic (4), get result 4, no errors. 4. Do arithmetic ((4))*(5), get result 20, no errors. 5. Because operator “^” has right associativity, we do arithmetic (3)^(((4))*(5)), e.g. (3)^(20) first. 20 is a negative number, and negative numbers are not allowed as an exponent, so the calculator simply outputs error message and stops. Notes: Because ““ has two meanings, the calculator will treat it as an unary operation at first, and if it fails, ““ would be treated as minus operation then. Write a program to simulate the calculator. Input The first line of the input file is an integer T<=200, then following T test cases. Each test case has only one line, the input expression given to the calculator. Each expression has no more than 2000 characters. Output For each test case, output one line contains the case number and the final result or “ERROR!” if any error occurs. See sample for detailed format. Sample Input 6 2^(1 2  9)^(5%3) 98**7 4%(2^01) 5%3+5%3 7^100 (73)^(37) Sample Output Case 1: 512 Case 2: ERROR! Case 3: ERROR! Case 4: 4 Case 5: ERROR! Case 6: ERROR!
 Break the Chocolate 的问题
 Problem Description Benjamin is going to host a party for his big promotion coming up. Every party needs candies, chocolates and beer, and of course Benjamin has prepared some of those. But as everyone likes to party, many more people showed up than he expected. The good news is that candies are enough. And for the beer, he only needs to buy some extra cups. The only problem is the chocolate. As Benjamin is only a 'small court officer' with poor salary even after his promotion, he can not afford to buy extra chocolate. So he decides to break the chocolate cubes into smaller pieces so that everyone can have some. He have two methods to break the chocolate. He can pick one piece of chocolate and break it into two pieces with bare hand, or put some pieces of chocolate together on the table and cut them with a knife at one time. You can assume that the knife is long enough to cut as many pieces of chocolate as he want. The party is coming really soon and breaking the chocolate is not an easy job. He wants to know what is the minimum number of steps to break the chocolate into unitsize pieces (cubes of size 1 × 1 × 1). He is not sure whether he can find a knife or not, so he wants to know the answer for both situations. Input The first line contains an integer T(1<= T <=10000), indicating the number of test cases. Each test case contains one line with three integers N,M,K(1 <=N,M,K <=2000), meaning the chocolate is a cube of size N ×M × K. Output For each test case in the input, print one line: "Case #X: A B", where X is the test case number (starting with 1) , A and B are the minimum numbers of steps to break the chocolate into N × M × K unitsize pieces with bare hands and knife respectively. Sample Input 2 1 1 3 2 2 2 Sample Output Case #1: 2 2 Case #2: 7 3
 The Little Girl who Picks Mushrooms 具体的实现
 Problem Description It's yet another festival season in Gensokyo. Little girl Alice planned to pick mushrooms in five mountains. She brought five bags with her and used different bags to collect mushrooms from different mountains. Each bag has a capacity of 2012 grams. Alice has finished picking mushrooms in 0 ≤ n ≤ 5 mountains. In the ith mountain, she picked 0 ≤ wi ≤ 2012 grams of mushrooms. Now she is moving forward to the remained mountains. After finishing picking mushrooms in all the five mountains, she want to bring as much mushrooms as possible home to cook a delicious soup. Alice lives in the forest of magic. At the entry of the forest of magic, live three mischievous fairies, Sunny, Lunar and Star. On Alice's way back home, to enter the forest, she must give them exactly three bags of mushrooms whose total weight must be of integral kilograms. If she cannot do so, she must leave all the five bags and enter the forest with no mushrooms. Somewhere in the forest of magic near Alice's house, lives a magician, Marisa. Marisa will steal 1 kilogram of mushrooms repeatedly from Alice until she has no more than 1 kilogram mushrooms in total. So when Alice gets home, what's the maximum possible amount of mushrooms Alice has? Remember that our common sense doesn't always hold in Gensokyo. People in Gensokyo believe that 1 kilogram is equal to 1024 grams. Input There are about 8192 test cases. Proceed to the end of file. The first line of each test case contains an integer 0 ≤ n ≤ 5, the number of mountains where Alice has picked mushrooms. The second line contains n integers 0 ≤ wi ≤ 2012, the amount of mushrooms picked in each mountain. Output For each test case, output the maximum possible amount of mushrooms Alice can bring home, modulo 20121014 (this is NOT a prime). Sample Input 1 9 4 512 512 512 512 5 100 200 300 400 500 5 208 308 508 708 1108 Sample Output 1024 1024 0 792
 终于明白阿里百度这样的大公司，为什么面试经常拿ThreadLocal考验求职者了
 点击上面↑「爱开发」关注我们每晚10点，捕获技术思考和创业资源洞察什么是ThreadLocalThreadLocal是一个本地线程副本变量工具类，各个线程都拥有一份线程私有的数
 win10系统安装教程（U盘PE+UEFI安装）
 一、准备工作 u盘，电脑一台，win10原版镜像（msdn官网） 二、下载wepe工具箱 极力推荐微pe（微pe官方下载） 下载64位的win10 pe，使用工具箱制作启动U盘打开软件， 选择安装到U盘（按照操作无需更改） 三、重启进入pe系统 1、关机后，将U盘插入电脑 2、按下电源后，按住F12进入启动项选择（技嘉主板是F12） 选择需要启
 程序员必须掌握的核心算法有哪些？
 由于我之前一直强调数据结构以及算法学习的重要性，所以就有一些读者经常问我，数据结构与算法应该要学习到哪个程度呢？，说实话，这个问题我不知道要怎么回答你，主要取决于你想学习到哪些程度，不过针对这个问题，我稍微总结一下我学过的算法知识点，以及我觉得值得学习的算法。这些算法与数据结构的学习大多数是零散的，并没有一本把他们全部覆盖的书籍。下面是我觉得值得学习的一些算法以及数据结构，当然，我也会整理一些看过
 《奇巧淫技》系列python！！每天早上八点自动发送天气预报邮件到QQ邮箱
 将代码部署服务器，每日早上定时获取到天气数据，并发送到邮箱。 也可以说是一个小人工智障。 思路可以运用在不同地方，主要介绍的是思路。
 Nginx 软件层面加强Nginx性能优化的面试问答和解决方案
 Nginx 软件层面加强Nginx性能优化的面试问答和解决方案 去年我去爱卡汽车面试PHP，一轮和二轮面的都不错，在三轮面到Nginx的时候很多问题当时不知道怎么回答，确实没有深入学习过，花了一段时间的学习，终于能解答Nginx高性能优化的问题了，10月24号为了获得程序员勋章，发布了半个优化笔记，浏览到了1000+，受到这个鼓舞，我抽时间在仔细整理下关于Nginx性能优化的问题，我们从软件说起。...
 【管理系统课程设计】美少女手把手教你后台管理
 【文章后台管理系统】URL设计与建模分析+项目源码+运行界面 栏目管理、文章列表、用户管理、角色管理、权限管理模块（文章最后附有源码） 1. 这是一个什么系统? 1.1 学习后台管理系统的原因 随着时代的变迁，现如今各大云服务平台横空出世，市面上有许多如学生信息系统、图书阅读系统、停车场管理系统等的管理系统，而本人家里就有人在用烟草销售系统，直接在网上完成挑选、购买与提交收货点，方便又快捷。 试想，若没有烟草销售系统，本人家人想要购买烟草，还要独自前往药...
 11月19日科技资讯华为明日发布鸿蒙整体战略；京东宣告全面向技术转型；Kotlin 1.3.60 发布
 「极客头条」—— 技术人员的新闻圈！ CSDN 的读者朋友们早上好哇，「极客头条」来啦，快来看今天都有哪些值得我们技术人关注的重要新闻吧。扫描上方二维码进入 CSDN App 可以收听御姐萌妹 Style 的人工版音频哟。 一分钟速览新闻点！ 6G 专家组成员：速率是 5G 的 10 至 100 倍，预计 2030 年商用 雷军：很多人多次劝我放弃WPS，能坚持下来并不是纯粹的商业决定 ...
 C语言魔塔游戏
 很早就很想写这个，今天终于写完了。 游戏截图： 编译环境: VS2017 游戏需要一些图片，如果有想要的或者对游戏有什么看法的可以加我的QQ 2985486630 讨论，如果暂时没有回应，可以在博客下方留言，到时候我会看到。 下面我来介绍一下游戏的主要功能和实现方式 首先是玩家的定义，使用结构体，这个名字是可以自己改变的 struct gamerole { char n
 化繁为简  腾讯计费高一致TDXA的实践之路
 导语：腾讯计费是孵化于支撑腾讯内部业务千亿级营收的互联网计费平台，在如此庞大的业务体量下，腾讯计费要支撑业务的快速增长，同时还要保证每笔交易不错账。采用最终一致性或离线补...
 Python爬虫爬取淘宝，京东商品信息
 小编是一个理科生，不善长说一些废话。简单介绍下原理然后直接上代码。 使用的工具（Python+pycharm2019.3+selenium+xpath+chromedriver）其中要使用pycharm也可以私聊我selenium是一个框架可以通过pip下载 pip install selenium i https://pypi.tuna.tsinghua.edu.cn/simple/
 Java学习笔记（七十二）—— Cookie
 概述 会话技术： 会话：一次会话中包含多次请求和响应 一次会话：浏览器第一次给服务器发送资源请求，会话建立，直到有一方断开为止 功能：在一次会话的范围内的多次请求间，共享数据 方式： 客户端会话技术：Cookie，把数据存储到客户端 服务器端会话技术：Session，把数据存储到服务器端 Cookie 概念：客户端会话技术，将数据存储到客户端 快速入门： 使用步骤： 创建C
 阿里程序员写了一个新手都写不出的低级bug，被骂惨了。
 这种新手都不会范的错，居然被一个工作好几年的小伙子写出来，差点被当场开除了。
 Java工作4年来应聘要16K最后没要,细节如下。。。
 前奏： 今天2B哥和大家分享一位前几天面试的一位应聘者，工作4年26岁，统招本科。 以下就是他的简历和面试情况。 基本情况： 专业技能： 1、 熟悉Sping了解SpringMVC、SpringBoot、Mybatis等框架、了解SpringCloud微服务 2、 熟悉常用项目管理工具：SVN、GIT、MAVEN、Jenkins 3、 熟悉Nginx、tomca
 2020年，冯唐49岁：我给20、30岁IT职场年轻人的建议
 点击“技术领导力”关注∆ 每天早上8:30推送 作者 Mr.K 编辑 Emma 来源 技术领导力(ID：jishulingdaoli) 前天的推文《冯唐：职场人35岁以后，方法论比经验重要》，收到了不少读者的反馈，觉得挺受启发。其实，冯唐写了不少关于职场方面的文章，都挺不错的。可惜大家只记住了“春风十里不如你”、“如何避免成为油腻腻的中年人”等不那么正经的文章。 本文整理了冯
 程序员该看的几部电影
 ##1、骇客帝国(1999) 概念：在线/离线，递归，循环，矩阵等 剧情简介： 不久的将来，网络黑客尼奥对这个看似正常的现实世界产生了怀疑。 他结识了黑客崔妮蒂，并见到了黑客组织的首领墨菲斯。 墨菲斯告诉他，现实世界其实是由一个名叫“母体”的计算机人工智能系统控制，人们就像他们饲养的动物，没有自由和思想，而尼奥就是能够拯救人类的救世主。 可是，救赎之路从来都不会一帆风顺，到底哪里才是真实的世界？
 作为一个程序员，CPU的这些硬核知识你必须会！
 CPU对每个程序员来说，是个既熟悉又陌生的东西？ 如果你只知道CPU是中央处理器的话，那可能对你并没有什么用，那么作为程序员的我们，必须要搞懂的就是CPU这家伙是如何运行的，尤其要搞懂它里面的寄存器是怎么一回事，因为这将让你从底层明白程序的运行机制。 随我一起，来好好认识下CPU这货吧 把CPU掰开来看 对于CPU来说，我们首先就要搞明白它是怎么回事，也就是它的内部构造，当然，CPU那么牛的一个东
 @程序员，如何花式构建线程？
 作者 曾建责编  郭芮出品  CSDN（ID：CSDNnews）在项目和业务的开发中，我们难免要经常使用线程来进行业务处理，使用线程可以保证我们的业务在相互处理之间可以保证原子性...
 破14亿，Python分析我国存在哪些人口危机！
 2020年1月17日，国家统计局发布了2019年国民经济报告，报告中指出我国人口突破14亿。 猪哥的朋友圈被14亿人口刷屏，但是很多人并没有看到我国复杂的人口问题：老龄化、男女比例失衡、生育率下降、人口红利下降等。 今天我们就来分析一下我们国家的人口数据吧！ 一、背景 1.人口突破14亿 2020年1月17日，国家统计局发布了 2019年国民经济报告 ，报告中指出：年末中国大陆总人口（包括31个
 强烈推荐10本程序员在家读的书
 很遗憾，这个鼠年春节注定是刻骨铭心的，新型冠状病毒让每个人的神经都是紧绷的。那些处在武汉的白衣天使们，尤其值得我们的尊敬。而我们这些窝在家里的程序员，能不外出就不外出，就是对社会做出的最大的贡献。 有些读者私下问我，窝了几天，有点颓丧，能否推荐几本书在家里看看。我花了一天的时间，挑选了 10 本我最喜欢的书，你可以挑选感兴趣的来读一读。读书不仅可以平复恐惧的压力，还可以对未来充满希望，毕竟苦难终
 Linux自学篇——linux命令英文全称及解释
 man: Manual 意思是手册，可以用这个命令查询其他命令的用法。 pwd：Print working directory 显示当前目录 su：Swith user 切换用户，切换到root用户 cd：Change directory 切换目录 ls：List files 列出目录下的文件 ps：Process Status 进程状态 mk
 Python实战：抓肺炎疫情实时数据，画2019nCoV疫情地图
 文章目录1. 前言2. 数据下载3. 数据处理4. 数据可视化 1. 前言 今天，群里白垩老师问如何用python画武汉肺炎疫情地图。白垩老师是研究海洋生态与地球生物的学者，国家重点实验室成员，于不惑之年学习python，实为我等学习楷模。先前我并没有关注武汉肺炎的具体数据，也没有画过类似的数据分布图。于是就拿了两个小时，专门研究了一下，遂成此文。 2月6日追记：本文发布后，腾讯的数据源多次变更u
 智力题（程序员面试经典）
 NO.1 有20瓶药丸，其中19瓶装有1克/粒的药丸，余下一瓶装有1.1克/粒的药丸。给你一台称重精准的天平，怎么找出比较重的那瓶药丸？天平只能用一次。 解法 有时候，严格的限制条件有可能反倒是解题的线索。在这个问题中，限制条件是天平只能用一次。 因为天平只能用一次，我们也得以知道一个有趣的事实：一次必须同时称很多药丸，其实更准确地说，是必须从19瓶拿出药丸进行称重。否则，如果跳过两瓶或更多瓶药
 在家远程办公效率低？那你一定要收好这个「在家办公」神器！
 相信大家都已经收到国务院延长春节假期的消息，接下来，在家远程办公可能将会持续一段时间。 但是问题来了。远程办公不是人在电脑前就当坐班了，相反，对于沟通效率，文件协作，以及信息安全都有着极高的要求。有着非常多的挑战，比如： 1在异地互相不见面的会议上，如何提高沟通效率？ 2文件之间的来往反馈如何做到及时性？如何保证信息安全？ 3如何规划安排每天工作，以及如何进行成果验收？ ......
 作为一个程序员，内存和磁盘的这些事情，你不得不知道啊！！！
 截止目前，我已经分享了如下几篇文章： 一个程序在计算机中是如何运行的？超级干货！！！ 作为一个程序员，CPU的这些硬核知识你必须会！ 作为一个程序员，内存的这些硬核知识你必须懂！ 这些知识可以说是我们之前都不太重视的基础知识，可能大家在上大学的时候都学习过了，但是嘞，当时由于老师讲解的没那么有趣，又加上这些知识本身就比较枯燥，所以嘞，大家当初几乎等于没学。 再说啦，学习这些，也看不出来有什么用啊！
 2020年的1月，我辞掉了我的第一份工作
 其实，这篇文章，我应该早点写的，毕竟现在已经2月份了。不过一些其它原因，或者是我的惰性、还有一些迷茫的念头，让自己迟迟没有试着写一点东西，记录下，或者说是总结下自己前3年的工作上的经历、学习的过程。 我自己知道的，在写自己的博客方面，我的文笔很一般，非技术类的文章不想去写；另外我又是一个还比较热衷于技术的人，而平常复杂一点的东西，如果想写文章写的清楚点，是需要足够...
 别低估自己的直觉，也别高估自己的智商
 所有群全部吵翻天，朋友圈全部沦陷，公众号疯狂转发。这两周没怎么发原创，只发新闻，可能有人注意到了。我不是懒，是文章写了却没发，因为大家的关注力始终在这次的疫情上面，发了也没人看。当然，我...
 Java坑人面试题系列: 包装类（中级难度）
 Java Magazine上面有一个专门坑人的面试题系列: https://blogs.oracle.com/javamagazine/quiz2。 这些问题的设计宗旨，主要是测试面试者对Java语言的了解程度，而不是为了用弯弯绕绕的手段把面试者搞蒙。 如果你看过往期的问题，就会发现每一个都不简单。 这些试题模拟了认证考试中的一些难题。 而 “中级(intermediate)” 和 “高级(ad
 Spring Boot 2.x基础教程：使用JdbcTemplate访问MySQL数据库
 在第2章节中，我们介绍了如何通过Spring Boot来实现HTTP接口，以及围绕HTTP接口相关的单元测试、文档生成等实用技能。但是，这些内容还不足以帮助我们构建一个动态应用的服务端程序。不论我们是要做App、小程序、还是传统的Web站点，对于用户的信息、相关业务的内容，通常都需要对其进行存储，而不是像第2章节中那样，把用户信息存储在内存中（重启就丢了！）。 对于信息的存储，现在已经有非常非常多...
 基于Python的人脸自动戴口罩系统
 目录 1、项目背景 2、页面设计 3、器官识别 4、退出系统 1、项目背景 2019年新型冠状病毒感染的肺炎疫情发生以来，牵动人心，举国哀痛，口罩、酒精、消毒液奇货可居。 抢不到口罩，怎么办？作为技术人今天分享如何使用Python实现自动戴口罩系统，来安慰自己，系统效果如下所示： 本系统的实现原理是借助 Dlib模块的Landmark人脸68个关键点检测库轻松识别出人脸五官
 这个世界上人真的分三六九等，你信吗？
 偶然间，在知乎上看到一个问题 一时间，勾起了我深深的回忆。 以前在厂里打过两次工，做过家教，干过辅导班，做过中介。零下几度的晚上，贴过广告，满脸、满手地长冻疮。 再回首那段岁月，虽然苦，但让我学会了坚持和忍耐。让我明白了，在这个世界上，无论环境多么的恶劣，只要心存希望，星星之火，亦可燎原。 下文是原回答，希望能对你能有所启发。 如果我说，这个世界上人真的分三六九等，...