 提取数列中的因子的一个算法问题，怎么利用C语言的程序的计算的方式实现？

Problem Description
There is a sequence of n positive integers. Fancycoder is addicted to learn their product, but this product may be extremely huge! However, it is lucky that FancyCoder only needs to find out one factor of this huge product: the smallest factor that contains more than 2 factors（including itself; i.e. 4 has 3 factors so that it is a qualified factor）. You need to find it out and print it. As we know, there may be none of such factors; in this occasion, please print 1 instead.Input
The first line contains one integer T (1≤T≤15), which represents the number of testcases.For each testcase, there are two lines:
The first line contains one integer denoting the value of n (1≤n≤100).
The second line contains n integers a1,…,an (1≤a1,…,an≤2×109), which denote these n positive integers.
Output
Print T answers in T lines.Sample Input
2
3
1 2 3
5
6 6 6 6 6Sample Output
6
4
一个数的所有因子（求更简单的算法）_course
20030805下面是我做的程序，，， 要求不用指针、数组。。有没有更简单的算法？？？ #include "stdio.h" void main() { int n; void aver(int num); prin
数列分段判断的算法问题求解，怎么利用C语言的程序设计思想的方式去实现算法呢？_course
20190521Problem Description Zty has met a big problem.His X Gu Niang was kidnaped by a secret organization.The organization only left Zty a letter: "If you can beat our boss ,we will give her the freedom,or..." The boss of the organization was so secret that no one knows his name.We only know that he was so powerful,and Zty is not powerful enough now,what he need to do is to train and to get more experience(Exp).Then he found a place wonderful for traning,There are N enemies there with different Exp,and Zty has M power ball,the number of power ball he used will effect the probability he beat the enemy.These probabilities are given as percentages pij, where i (with 1 ≤ i ≤ N) is the number of the enemy and j is the quantity of power balls used on it.One power ball can be used only once. Zty has to level up to 99,then he will be able to beat the boss.Of cause he is level 1 at the begining.He want to know weather the maximal expected Exp he can get is enough.The expected Exp is calculated as Sum(P(i)*Exp) where P is the probability. The Exp Zty need to level up one level is K/100 , and K will be given. Notice that: If Zty doesn't used a power ball,the probability he beat the enemy is 0. ^_^ Input The first line contain a T ,then T cases followed.Each test case has the following format: One line with one integer K <= 100000: as the description means. One line with one integer N with 1 ≤ N ≤ 100: the number of enemies. One line with one integer M with 0 ≤ M ≤ 100: the maximal number of available power ball. One line with N integers indicating the Exp of the N enemies. N lines, each line corresponding to a enemy i, containing n integers pi1, pi2, …, pim (the percentages, with 0 ≤ pi1, pi2, …, pim ≤ 100). Output If the maximal expected Exp Zty can get is enough for him to level up tp 99,then ouput "Love you Ten thousand years.",else ouput"Cry,men,not crime." Sample Input 2 1000 2 4 8 975 85 94 93 100 0 0 100 100 1000 1 4 979 0 0 0 100 Sample Output Love you Ten thousand years. Cry,men,not crime.
数列排序组合的一个算法问题，是怎么采用的C语言的程序的编写的设计的过程的方式的技术去实现呢_course
20190616Problem Description Cut or not to cut, it is a question. In Fruit Ninja, comprising three or more fruit in one cut gains extra bonuses. This kind of cuts are called bonus cuts. Also, performing the bonus cuts in a short time are considered continual, iff. when all the bonus cuts are sorted, the time difference between every adjacent cuts is no more than a given period length of W. As a fruit master, you have predicted the times of potential bonus cuts though the whole game. Now, your task is to determine how to cut the fruits in order to gain the most bonuses, namely, the largest number of continual bonus cuts. Obviously, each fruit is allowed to cut at most once. i.e. After previous cut, a fruit will be regarded as invisible and won't be cut any more. In addition, you must cut all the fruit altogether in one potential cut. i.e. If your potential cut contains 6 fruits, 2 of which have been cut previously, the 4 left fruits have to be cut altogether. Input There are multiple test cases. The first line contains an integer, the number of test cases. In each test case, there are three integer in the first line: N(N<=30), the number of predicted cuts, M(M<=200), the number of fruits, W(W<=100), the time window. N lines follows. In each line, the first integer Ci(Ci<=10) indicates the number of fruits in the ith cuts. The second integer Ti(Ti<=2000) indicate the time of this cut. It is guaranteed that every time is unique among all the cuts. Then follow Ci numbers, ranging from 0 to M1, representing the identifier of each fruit. If two identifiers in different cuts are the same, it means they represent the same fruit. Output For each test case, the first line contains one integer A, the largest number of continual bonus cuts. In the second line, there are A integers, K1, K2, ..., K_A, ranging from 1 to N, indicating the (Ki)th cuts are included in the answer. The integers are in ascending order and each separated by one space. If there are multiple best solutions, any one is accepted. Sample Input 1 4 10 4 3 1 1 2 3 4 3 3 4 6 5 3 7 7 8 9 3 5 9 5 4 Sample Output 3 1 2 3
一个数列级数的判断计算的问题的解答的方式，如何利用C语言的程序设计的方式来实现_course
20190331Problem Description You are the CEO of Nasty Hacks Inc., a company that creates small pieces of malicious software which teenagers may use to fool their friends. The company has just finished their first product and it is time to sell it. You want to make as much money as possible and consider advertising in order to increase sales. You get an analyst to predict the expected revenue, both with and without advertising. You now want to make a decision as to whether you should advertise or not, given the expected revenues. Input The input consists of n cases, and the first line consists of one positive integer giving n. The next n lines each contain 3 integers, r, e and c. The first, r, is the expected revenue if you do not advertise, the second, e, is the expected revenue if you do advertise, and the third, c, is the cost of advertising. You can assume that the input will follow these restrictions: 106 ≤ r, e ≤ 106 and 0 ≤ c ≤ 106. Output Output one line for each test case: “advertise”, “do not advertise” or “does not matter”, presenting whether it is most profitable to advertise or not, or whether it does not make any difference. Sample Input 3 0 100 70 100 130 30 100 70 40 Sample Output advertise does not matter do not advertise
数列循环求核的问题不回溯计算方式，采用C语言的编程技术实现_course
20190324Problem Description There are n apple trees planted along a cyclic road, which is L metres long. Your storehouse is built at position 0 on that cyclic road. The ith tree is planted at position xi, clockwise from position 0. There are ai delicious apple(s) on the ith tree. You only have a basket which can contain at most K apple(s). You are to start from your storehouse, pick all the apples and carry them back to your storehouse using your basket. What is your minimum distance travelled? 1≤n,k≤105,ai≥1,a1+a2+...+an≤105 1≤L≤109 0≤x[i]≤L There are less than 20 huge testcases, and less than 500 small testcases. Input First line: t, the number of testcases. Then t testcases follow. In each testcase: First line contains three integers, L,n,K. Next n lines, each line contains xi,ai. Output Output total distance in a line for each testcase. Sample Input 2 10 3 2 2 2 8 2 5 1 10 4 1 2 2 8 2 5 1 0 10000 Sample Output 18 26
数列组成一个字符串的计算问题怎么用的C语言比较好_course
20190806Problem Description After little Jim learned Fibonacci Number in the class , he was very interest in it. Now he is thinking about a new thing  Fibonacci String . He defines : str[n] = str[n1] + str[n2] ( n > 1 ) He is so crazying that if someone gives him two strings str[0] and str[1], he will calculate the str[2],str[3],str[4] , str[5].... For example : If str[0] = "ab"; str[1] = "bc"; he will get the result , str[2]="abbc", str[3]="bcabbc" , str[4]="abbcbcabbc" …………; As the string is too long ,Jim can't write down all the strings in paper. So he just want to know how many times each letter appears in Kth Fibonacci String . Can you help him ? Input The first line contains a integer N which indicates the number of test cases. Then N cases follow. In each case,there are two strings str[0], str[1] and a integer K (0 <= K < 50) which are separated by a blank. The string in the input will only contains less than 30 lowcase letters. Output For each case,you should count how many times each letter appears in the Kth Fibonacci String and print out them in the format "X:N". If you still have some questions, look the sample output carefully. Please output a blank line after each test case. To make the problem easier, you can assume the result will in the range of int. Sample Input 1 ab bc 3 Sample Output a:1 b:3 c:2 d:0 e:0 f:0 g:0 h:0 i:0 j:0 k:0 l:0 m:0 n:0 o:0 p:0 q:0 r:0 s:0 t:0 u:0 v:0 w:0 x:0 y:0 z:0
数列的翻转表的一个算法的问题的求解，用C语言的程序编写怎么实现的啊_course
20190326Problem Description Let { A1,A2,...,An } be a permutation of the set{ 1,2,..., n}. If i < j and Ai > Aj then the pair (Ai,Aj) is called an "inversion" of the permutation. For example, the permutation {3, 1, 4, 2} has three inversions: (3,1), (3,2) and (4,2). The inversion table B1,B2,...,Bn of the permutation { A1,A2,...,An } is obtained by letting Bj be the number of elements to the left of j that are greater than j. (In other words, Bj is the number of inversions whose second component is j.) For example, the permutation: { 5,9,1,8,2,6,4,7,3 } has the inversion table 2 3 6 4 0 2 2 1 0 since there are 2 numbers, 5 and 9, to the left of 1; 3 numbers, 5, 9 and 8, to the left of 2; etc. Perhaps the most important fact about inversions is Marshall Hall's observation that an inversion table uniquely determines the corresponding permutation. So your task is to convert a permutation to its inversion table, or vise versa, to convert from an inversion table to the corresponding permutation. Input The input consists of several test cases. Each test case contains two lines. The first line contains a single integer N ( 1 <= N <= 50) which indicates the number of elements in the permutation/invertion table. The second line begins with a single charactor either 'P', meaning that the next N integers form a permutation, or 'I', meaning that the next N integers form an inversion table. Output For each case of the input output a line of intergers, seperated by a single space (no space at the end of the line). If the input is a permutation, your output will be the corresponding inversion table; if the input is an inversion table, your output will be the corresponding permutation. Sample Input 9 P 5 9 1 8 2 6 4 7 3 9 I 2 3 6 4 0 2 2 1 0 0 Sample Output 2 3 6 4 0 2 2 1 0 5 9 1 8 2 6 4 7 3
数列累积核的问题，数据结构的算法怎么利用C语言的形式实现_course
20190320Problem Description Expression trees, B and B* trees, redblack trees, quad trees, PQ trees; trees play a significant role in many domains of computer science. Sometimes the name of a problem may indicate that trees are used when they are not, as in the Artificial Intelligence planning problem traditionally called the Monkey and Bananas problem. Sometimes trees may be used in a problem whose name gives no indication that trees are involved, as in the Huffman code. This problem involves determining how pairs of people who may be part of a ``family tree'' are related. Given a sequence of childparent pairs, where a pair consists of the child's name followed by the (single) parent's name, and a list of query pairs also expressed as two names, you are to write a program to determine whether the query pairs are related. If the names comprising a query pair are related the program should determine what the relationship is. Consider academic advisees and advisors as exemplars of such a single parent genealogy (we assume a single advisor, i.e., no coadvisors). In this problem the childparent pair p q denotes that p is the child of q. In determining relationships between names we use the following definitions: p is a 0descendent of q (respectively 0ancestor) if and only if the childparent pair p q (respectively q,p ) appears in the input sequence of childparent pairs. p is a kdescendent of q (respectively kancestor) if and only if the childparent pair p r (respectively q r) appears in the input sequence and r is a (k1)descendent of q (respectively p is a (k1)ancestor of r). For the purposes of this problem the relationship between a person p and a person q is expressed as exactly one of the following four relations: 1 child  grand child, great grand child, great great grand child, etc. By definition p is the ``child'' of q if and only if the pair p q appears in the input sequence of childparent pairs (i.e., p is a 0descendent of q); p is the ``grand child'' of q if and only if p is a 1descendent of q; and if and only if p is an (n+1)descendent of q. 2 parent  grand parent, great grand parent, great great grand parent, etc. By definition p is the ``parent'' of q if and only if the pair appears in the input sequence of childparent pairs p q (i.e., p is a 0ancestor of q); p is the ``grand parent'' of q if and only if p is a 1ancestor of q; and if and only if p is an (n+1)ancestor of q. 3 cousin  0 th cousin, 1 st cousin, 2 nd cousin, etc.; cousins may be once removed, twice removed, three times removed, etc. By definition p and q are ``cousins'' if and only if they are related (i.e., there is a path from p to q in the implicit undirected parentchild tree). Let r represent the least common ancestor of p and q (i.e., no descendent of r is an ancestor of both p and q), where p is an mdescendent of r and q is an ndescendent of r. Then, by definition, cousins p and q are `k th` cousins'' if and only if k=min(n,m) , and, also by definition, p and q are ``cousins removed j times'' if and only if j=nm. 4 sibling  0 th cousins removed 0 times are ``siblings'' (they have the same parent). Input The input consists of parentchild pairs of names, one pair per line. Each name in a pair consists of lowercase alphabetic characters or periods (used to separate first and last names, for example). Child names are separated from parent names by one or more spaces. Parentchild pairs are terminated by a pair whose first component is the string ``no.child''. Such a pair is NOT to be considered as a parentchild pair, but only as a delimiter to separate the parentchild pairs from the query pairs. There will be no circular relationships, i.e., no name p can be both an ancestor and a descendent of the same name q. The parentchild pairs are followed by a sequence of query pairs in the same format as the parentchild pairs, i.e., each name in a query pair is a sequence of lowercase alphabetic characters and periods, and names are separated by one or more spaces. Query pairs are terminated by endoffile. There will be a maximum of 300 different names overall (parentchild and query pairs). All names will be fewer than 31 characters in length. There will be no more than 100 query pairs. Output For each querypair p q of names the output should indicate the relationship p istherelativeof q by the appropriate string of the form child, grand child, great grand child, great great ...great grand child parent, grand parent, great grand parent, great great ...great grand parent sibling n cousin removed m no relation If an mcousin is removed 0 times then only m cousin should be printed, i.e., removed 0 should NOT be printed. Do not print st, nd, rd, th after the numbers Sample Input alonzo.church oswald.veblen stephen.kleene alonzo.church dana.scott alonzo.church martin.davis alonzo.church pat.fischer hartley.rogers mike.paterson david.park dennis.ritchie pat.fischer hartley.rogers alonzo.church les.valiant mike.paterson bob.constable stephen.kleene david.park hartley.rogers no.child no.parent stephen.kleene bob.constable hartley.rogers stephen.kleene les.valiant alonzo.church les.valiant dennis.ritchie dennis.ritchie les.valiant pat.fischer michael.rabin Sample Output parent sibling great great grand child 1 cousin removed 1 1 cousin removed 1 no relation
数列对的问题，如何运用C语言的方式作答，利用C语言如何解决这个问题_course
20190224Problem Description Friend number are defined recursively as follows. (1) numbers 1 and 2 are friend number; (2) if a and b are friend numbers, so is ab+a+b; (3) only the numbers defined in (1) and (2) are friend number. Now your task is to judge whether an integer is a friend number. Input There are several lines in input, each line has a nunnegative integer a, 0<=a<=2^30. Output For the number a on each line of the input, if a is a friend number, output “YES!”, otherwise output “NO!”. Sample Input 3 13121 12131 Sample Output YES! YES! NO!
反推递增数列的一个算法的思路问题，怎么采用C语言的程序的设计的思想实现？_course
20190429Problem Description 很久很久以前曾经有一个古老的国度叫做bitland，bitland原本是三个小的国家，and, or, xor, 他们分别由各自的君主anddy, orry, xorry统治着，后来在三个君主的协商下，合并为一个共同的国家，并由三个君主共同制定宪法，在制定法律时，需要采用某种方式来管理三个国家的人口关系，为了体现自己国家的个性，三个君主分别制定了一条规则。分别是，三个国家的人口数and起来必须为0，三个国家的人口数or起来并取补必须为0，三个国家的人口数xor起来并取补必须为0. 这个联盟维持了上百年的时间，最终还是因为三个君主利益不合的问题而发生了分裂，战争爆发了，没有人知道一共经历了多少场大大小小的战斗。但古老的羊皮卷记载着战争的一些琐碎：bitland的每一个臣民都参加拿起了武器，参加到战斗中，每一个国家都将他们的所有人口编为很多小队，为了方便管理和记录，每个小队的人数必须是2的方幂（别忘了他们采用2进制计数），另外在分队时还会使小队的数目尽量地少。 当两个国家爆发一场战斗，他们派出各自的人数最少的一个小队，他们的战斗没有任何战术可言，人多的一方一定会胜利，并俘虏敌方的整个小队成为自己的战斗力，并将俘虏带回自己的国家。另外如果一个小队到达另外一个国家时，那个国家已经没有任何人口，他们就会生出反叛之心，自己占领那个国家。 几亿年后，战争终于结束了，三个国家又重归于好，bitland的臣民又过上了幸福的生活，没有人再提起那场战争，你是bitland的一个考古学家，当你从祖父口中偶然得知了这场辉煌的战争，你决定要去走访bitland的每一个角落，去了解这场战争的每一个细节。第一步，你必须去了解一共发生了多少场战斗。你查找古老的羊皮卷，得知了战争开始前每个国家有多少人口，并统计到了战争结束时三个国家的人口数，你现在希望算出至少发生过多少场战争。 Input 六行分别是六个整数,x1,y1,z1,x2,y2,z2，分别代表战争前和战争后三个国家的人口数(小于2*10^18) 若全为零则结束输入 Output 一个整数，即最少一共经历了多少战争(小于2*10^18); Sample Input 1 0 0 0 0 1 Sample Output 1 初始状态符合条件:1 and 0 and 0=0 not(1 or 0 or 0)=0 not(1 xor 0 xor 0)=0 最少经历了一场战争， 即and和xor发生一场战斗，and国家有1个小队，每个小队1人， xor国家没有人口，故and国家的小队会占领xor国家，人口数变成0,0,1.
数列的倍增的一个算法题目的求解的过程，如何利用C语言的计算的编程？_course
20190319Problem Description Ratish is a young man who always dreams of being a hero. One day his friend Luffy was caught by Pirate Arlong. Ratish set off at once to Arlong's island. When he got there, he found the secret place where his friend was kept, but he could not go straight in. He saw a large door in front of him and two locks in the door. Beside the large door, he found a strange rock, on which there were some odd words. The sentences were encrypted. But that was easy for Ratish, an amateur cryptographer. After decrypting all the sentences, Ratish knew the following facts: Behind the large door, there is a nesting prison, which consists of M floors. Each floor except the deepest one has a door leading to the next floor, and there are two locks in each of these doors. Ratish can pass through a door if he opens either of the two locks in it. There are 2N different types of locks in all. The same type of locks may appear in different doors, and a door may have two locks of the same type. There is only one key that can unlock one type of lock, so there are 2N keys for all the 2N types of locks. These 2N keys were made N pairs,one key may be appear in some pairs, and once one key in a pair is used, the other key will disappear and never show up again. Later, Ratish found N pairs of keys under the rock and a piece of paper recording exactly what kinds of locks are in the M doors. But Ratish doesn't know which floor Luffy is held, so he has to open as many doors as possible. Can you help him to choose N keys to open the maximum number of doors? Input There are several test cases. Every test case starts with a line containing two positive integers N (1 <= N <= 2^10) and M (1 <= M <= 2^11) separated by a space, the first integer represents the number of types of keys and the second integer represents the number of doors. The 2N keys are numbered 0, 1, 2, ..., 2N  1. Each of the following N lines contains two integers, which are the numbers of two keys in a pair. After that, each of the following M lines contains two integers, which are the numbers of two keys corresponding to the two locks in a door. You should note that the doors are given in the same order that Ratish will meet. A test case with N = M = 0 ends the input, and should not be processed. Output For each test case, output one line containing an integer, which is the maximum number of doors Ratish can open. Sample Input 3 6 0 3 1 2 4 5 0 1 0 2 4 1 4 2 3 5 2 2 0 0 Sample Output 4
数列的单向遍历的方式如何解决这个问题啊，C语言程序代码具体怎么实现_course
20190328Problem Description The Public Peace Commission should be legislated in Parliament of The Democratic Republic of Byteland according to The Very Important Law. Unfortunately one of the obstacles is the fact that some deputies do not get on with some others. The Commission has to fulfill the following conditions: 1.Each party has exactly one representative in the Commission, 2.If two deputies do not like each other, they cannot both belong to the Commission. Each party has exactly two deputies in the Parliament. All of them are numbered from 1 to 2n. Deputies with numbers 2i1 and 2i belong to the ith party . Task Write a program, which: 1.reads from the text file SPO.IN the number of parties and the pairs of deputies that are not on friendly terms, 2.decides whether it is possible to establish the Commission, and if so, proposes the list of members, 3.writes the result in the text file SPO.OUT. Input In the first line of the text file SPO.IN there are two nonnegative integers n and m. They denote respectively: the number of parties, 1 <= n <= 8000, and the number of pairs of deputies, who do not like each other, 0 <= m <=2 0000. In each of the following m lines there is written one pair of integers a and b, 1 <= a < b <= 2n, separated by a single space. It means that the deputies a and b do not like each other. There are multiple test cases. Process to end of file. Output The text file SPO.OUT should contain one word NIE (means NO in Polish), if the setting up of the Commission is impossible. In case when setting up of the Commission is possible the file SPO.OUT should contain n integers from the interval from 1 to 2n, written in the ascending order, indicating numbers of deputies who can form the Commission. Each of these numbers should be written in a separate line. If the Commission can be formed in various ways, your program may write mininum number sequence. Sample Input 3 2 1 3 2 4 Sample Output 1 4 5
偶数求和的一个运算的问题用的C语言的实现_course
20190814Problem Description 有一个长度为n(n<=100)的数列，该数列定义为从2开始的递增有序偶数，现在要求你按照顺序每m个数求出一个平均值，如果最后不足m个，则以实际数量求平均值。编程输出该平均值序列。 Input 输入数据有多组，每组占一行，包含两个正整数n和m，n和m的含义如上所述。 Output 对于每组输入数据，输出一个平均值序列，每组输出占一行。 Sample Input 3 2 4 2 Sample Output 3 6 3 7
数列数组的增加删除修改寻找的一个问题，采用C语言的程序设计的方式怎么实现代码的编写_course
20190327Problem Description It is known to us all that YY and LMY are mathematics lovers. They like to find and solve interesting mathematic problems together. Now LMY designs a game for matrix. There is a large matrix whose rows and columns are both not more than 1000000000. And there are three operations for the matrix: 1) add: Mark an element in the matrix. It is guaranteed that the element has not been marked before. 2) remove: Delete an element’s mark. It is guaranteed that the element has been marked before. 3) find: For a given element’s row and column, return a marked element’s row and column, where the marked element’s row and column are larger than the given element’s row and column respectively. If there are multiple solutions, return the element whose row is the smallest; and if there are still multiple solutions, return the element whose column is the smallest. If there is no solution, return 1. LMY lets YY develop a program to solve the problem. Could you also develop a program to solve the problem? Input The input consists of multiple test cases. For each test case, the first line contains only one integer n. n ≤ 200000. Each of the next n lines describes an operation. There is a blank line between two consecutive test cases. End of input is indicated by a line containing a zero. Output Start each test case with "Case #:" on a single line, where # is the case number starting from 1. For each “find” operation, output the result. The format is showed as sample output. There is a blank line between two consecutive test cases. Sample Input 5 add 48 1 add 25 69 add 88 52 remove 25 69 add 23 89 10 add 47 23 find 66 83 find 27 73 add 84 97 find 10 58 remove 47 23 add 41 89 remove 41 89 find 65 68 add 25 41 0 Sample Output Case 1: Case 2: 1 1 84 97 84 97
菲波那契数列(Fibonacci numbers)的一个算法问题，运用C语言实现的形式和做法_course
20190324Problem Description 任何一个大学生对菲波那契数列(Fibonacci numbers)应该都不会陌生，它是这样定义的： F(1)=1; F(2)=2; F(n)=F(n1)+F(n2)(n>=3); 所以，1,2,3,5,8,13……就是菲波那契数列。 在HDOJ上有不少相关的题目，比如1005 Fibonacci again就是曾经的浙江省赛题。 今天，又一个关于Fibonacci的题目出现了，它是一个小游戏，定义如下： 1、 这是一个二人游戏; 2、 一共有3堆石子，数量分别是m, n, p个； 3、 两人轮流走; 4、 每走一步可以选择任意一堆石子，然后取走f个； 5、 f只能是菲波那契数列中的元素（即每次只能取1，2，3，5，8…等数量）； 6、 最先取光所有石子的人为胜者； 假设双方都使用最优策略，请判断先手的人会赢还是后手的人会赢。 Input 输入数据包含多个测试用例，每个测试用例占一行，包含3个整数m,n,p（1<=m,n,p<=1000）。 m=n=p=0则表示输入结束。 Output 如果先手的人能赢，请输出“Fibo”，否则请输出“Nacci”，每个实例的输出占一行。 Sample Input 1 1 1 1 4 1 0 0 0 Sample Output Fibo Nacci
数列整数相邻判断的问题，如何利用C语言的功能去实现的_course
20190303Problem Description You are working as a guide on a tour bus for retired people, and today you have taken your regular Nordic seniors to The Gate of Heavenly Peace. You let them have a lunch break where they could do whatever they like. Now you have to get them back to the bus, but they are all walking in random directions. You try to intersect them, and send them straight back to the bus. Minimize the time before the last person is in the bus. You will always be able to run faster than any of the tour guests, and they walk with constant speed, no matter what you tell them. The seniors walk in straight lines, and the only way of changing their direction is to give them promises of camphor candy. A senior will neither stop at nor enter the bus before given such a promise. Input A number of test cases consisting of: A line with an integer 1 ≤ n ≤ 8, the number of people on the tour. A line with an floating point number 1 < v ≤ 100, your maximum speed (you start in the bus at the origin). Then follow n lines, each containing four floating point numbers xi yi vi ai, the starting coordinates (106 ≤ xi, yi ≤ 106), speed (1 ≤ vi < 100) and direction (0 ≤ ai < 2π) of each of the tour guests. The input is terminated by a case with n = 0, which should not be processed. All floating point numbers in the input will be written in standard decimal notation, and have no more than 10 digits. Output For each test case, print a line with the time it takes before everybody is back in the bus (the origin). Round the answer to the nearest integer. The answer will never be larger than 106. Sample Input 1 50.0 125.0 175.0 25.0 1.96 3 100.0 40.0 25.0 20.0 5.95 185.0 195.0 6.0 2.35 30.0 80.0 23.0 2.76 0 Sample Output 20 51
偶数求和的计算的一个问题，如何利用C语言来表达_course
20190808Problem Description 有一个长度为n(n<=100)的数列，该数列定义为从2开始的递增有序偶数，现在要求你按照顺序每m个数求出一个平均值，如果最后不足m个，则以实际数量求平均值。编程输出该平均值序列。 Input 输入数据有多组，每组占一行，包含两个正整数n和m，n和m的含义如上所述。 Output 对于每组输入数据，输出一个平均值序列，每组输出占一行。 Sample Input 3 2 4 2 Sample Output 3 6 3 7
数列级数的极值的计算的一个问题，请问是如何利用C语言的编程代码实现的呢_course
20190215Problem Description At present, the university rankings are very popublar.They help senior high school students to choose universities for study.For example,you can find the CHINESE UNIVERSITY RANGKINGS at http://www.netbig.com/. As we know ,a university ususally has many different departments,such as department of Language(FLS).some of them are quit good when comparing to other universities,but others are not.So,most of universities'rangkings are are composed of several ranking lists, each list for one department. But here comes a problem that sometimes it's hard to determine which universities is better,when comparing two universities with each othe.Fortunately,Doctor Bob has advanced a new concept named "absolutely better",with which the problem above can be solved. Now,here is a an example to explain the concept "absolutely better": Assum that there are three universities (X,Y,Z)and every university has three department:CS,EE and FLS.And the rangkings of the departments are as the followed: The rankings of the CS:X>Y>Z(X>Y means X has a better CS department than Y) The rankings of the EE:X>Z>Y The rankings of the FLS:Z>X>y Obviously,each each department of University X is better than that of University Y. Then,it's called that X is absolutely better than Y.Using the "absolutely better"concept, it becomes better to compare some paires of Universities. Now Bob has the complete rangkings of different departments of many universities,and he wants to find k universities(U1,u2,....Uk)such that Ui is absolutely better that Uj(for any i<j). Input The first line of the input is a positive integer C.C is the number of test cases followed. The first line of each test case is two positive integers N,M(0<N,M<=100),N is the number of the universities and M is the number of departments.And then M lines follow.The i(th)(1<=i<=M)line contains N numbers Ui(1<=i<=N,1<=Ui<=N),indicating the ranking of the i(th)department.If Universitites Ui preceds to University Uj in line k(th department, then the k(th)department do Ui is better than k(th) department of Uj. Output The output should consist fo C lines, one lines for each test case.Each line only constains one integer the maximum values fo k as descriped above.No redundant spaces are needed. Sample Input 1 3 3 1 2 3 1 3 2 3 1 2 Sample Output 2
数列中寻找的最大的因子，怎么利用 C语言的程序代码的思想去实现的？_course
20190509Problem Description To improve the organization of his farm, Farmer John labels each of his N (1 <= N <= 5,000) cows with a distinct serial number in the range 1..20,000. Unfortunately, he is unaware that the cows interpret some serial numbers as better than others. In particular, a cow whose serial number has the highest prime factor enjoys the highest social standing among all the other cows. (Recall that a prime number is just a number that has no divisors except for 1 and itself. The number 7 is prime while the number 6, being divisible by 2 and 3, is not). Given a set of N (1 <= N <= 5,000) serial numbers in the range 1..20,000, determine the one that has the largest prime factor. Input * Line 1: A single integer, N * Lines 2..N+1: The serial numbers to be tested, one per line Output * Line 1: The integer with the largest prime factor. If there are more than one, output the one that appears earliest in the input file. Sample Input 4 36 38 40 42 Sample Output 38
一个数列数组的求和再求比率的问题，如何利用C语言的方法编程算法解决_course
20190209Problem Description As a cheap labor in a small company, LL has to ride back and forth between school and office every day. It is a tedious trip. So he want to design the most satisfactory riding route. After several day's experiment, he draw the simple map. It contains n*m areas. The school is in (0,0) while the office is in (n1,m1). He also record the scenery rank of each area A(i,j) and the time need to ride through each area B(i,j). ( For the start and end, A(0,0), B(0,0), A(n1,m1), B(n1,m1) are always 0. ) Now, LL defines the satisfactory degree of a round trip as follow: ∑{ A(i,j)  Area (i,j) is in the riding route (come or go). } the satisfactory degree =  ∑{ B(i,j)  Area (i,j) is in the riding route (come or go). } Attention: 1. LL doesn't want to make a detour. So, from school to office he only ride rightward or downward and from office to school only leftward or upward. 2. LL won't pass the same area in the whole round trip except the start and end. Input Each test case begins with two integers n,m ( 3<=n,m<=30 ), which is the size of the map. Then n lines follow, each contains m integers A(i,j). Another n lines follow, each contains m integers B(i,j). 1 <= A(i,j),B(i,j) <= 100. Output For each case, Output the maximal satisfactory degree he can get in a round trip. Sample Input 3 3 0 1 2 3 4 5 6 7 0 0 7 6 5 4 3 2 1 0 Sample Output 13/11
 11.3MB
2020年9月新版CKA真题
202010192020年九月新版CKA考试真题，是博主在考试时候偷偷截的图，考试是在线考试，具体的考试攻略可以参考我的博客，如有疑问可以在博客下面留言，我看到就会回复的。博客地址：https://blog.csdn
手把手带你学会Python
20200303当下最火的计算机语言，难道你还只停留知道的阶段吗？快跟着老司机一起起飞吧~ 零基础开始学，只要跟着视频一步一步来，多思考，多练习，我相信你会有质的飞越。 学习路上会很苦，也会很累。但是这些等你学会以后，会发现这些都是值得。 还在等什么？快来学习吧~
R语言入门基础
20190601本课程旨在帮助学习者快速入门R语言： 课程系统详细地介绍了使用R语言进行数据处理的基本思路和方法。 课程能够帮助初学者快速入门数据处理。 课程通过大量的案例详细地介绍了如何使用R语言进行数据分析和处理 课程操作实际案例教学，通过编写代码演示R语言的基本使用方法和技巧
Java进阶高手课Java基础编程提升
20200427课程聚焦Java基础编程提升的核心知识点，以真实场景项目实战为导向，循序渐进，深入浅出的了解Java基础编程，讲解Java这门使用广泛的编程语言，助你能够游刃有余地游走在这些技术之中。
 41.83MB
Python高级编程.pdf
20130801《Python高级编程》通过大量的实例，介绍了Python语言的最佳实践和敏捷开发方法，并涉及整个软件生命周期的高级主题，诸如持续集成、版本控制系统、包的发行和分发、开发模式、文档编写等。《Pytho
Python进阶Pandas数据分析库
20181218您观看课程学习后 免费入群领取【超全Python资料包+17本学习电子书】 Pandas是python中非常常用的数据分析库，在数据分析，机器学习，深度学习等领域经常被使用。本课程会讲解到pandas中最核心的一些知识点，包括Series以及DataFrame的构建，赋值，操作，选择数据，合并等等，以及使用pandas对文件进行读取和写入，使用pandas绘图等等。
 111.65MB
DirectX修复工具V4.0增强版
20200613DirectX修复工具(DirectX Repair)是一款系统级工具软件，简便易用。本程序为绿色版，无需安装，可直接运行。 本程序的主要功能是检测当前系统的DirectX状态，如果发现异常则进行修复
 学院 轻松搞定数据可视化
 博客 jQuery新手入门知识点
 学院 基于vue.js的uniapp手机数码商城APP（使用教程）
 学院 基于vue.js的uniapp母婴用品商城APP（使用教程）
 博客 jqueryeasyui1.5.4.5.zip
 博客 复杂网络作业六：Louvain社区发现算法原理，细节以及实现
 下载 防火墙白名单设置方法_iptables_centos6
 博客 spring
 博客 20201101
 学院 Flutter编程指南之跨平台APP开发：手把手带您完成【我的备忘录】
 下载 PID控制PWM温度系统.rar
 学院 Java+FFmpeg开发音视频流媒体直播等
 学院 深度学习之以图搜图实战（PyTorch + Faiss)
 下载 CRMEB_v4单商户 b2c +uniapp
 博客 机器学习 第一节 第八课
 学院 深度学习
 学院 Spring从入门到精通
 学院 大数据分析闯关训练营 04期直播回放
 学院 MT5编程从入门到精通（6阶段所有课程）
 下载 防火墙白名单设置方法_firewalld_centos7.pdf
 学院 Facebook工程师带你全解数据结构与算法
 学院 基于uniapp+springboot的商业项目（第一季）
 下载 单片机C语言实例（400例）.rar
 下载 kodexplorer4.4版本完美修改版.zip
 学院 FFmpeg4.3黄金系列课程：c++版
 下载 rabbitMq消息接收与消费
 博客 ECS云服务器安装宝塔面板的方法
 博客 虚拟主机、轻量应用服务器、ECS云服务器区别有哪些？
 博客 Java中的两种常用算法
 学院 企业级SpringBoot使用