标签：des style c class blog code
1001：
Energy Conversion Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 7787 Accepted Submission(s): 1894 Problem Description 魔法师百小度也有遇到难题的时候—— 现在，百小度正在一个古老的石门面前，石门上有一段古老的魔法文字，读懂这种魔法文字需要耗费大量的能量和大量的脑力。 过了许久，百小度终于读懂魔法文字的含义：石门里面有一个石盘，魔法师需要通过魔法将这个石盘旋转X度，以使上面的刻纹与天相对应，才能打开石门。 但是，旋转石盘需要N点能量值，而为了解读密文，百小度的能量值只剩M点了！破坏石门是不可能的，因为那将需要更多的能量。不过，幸运的是，作为魔法师的百小度可以耗费V点能量，使得自己的能量变为现在剩余能量的K倍（魔法师的世界你永远不懂，谁也不知道他是怎么做到的）。比如，现在百小度有A点能量,那么他可以使自己的能量变为(A-V)*K点（能量在任何时候都不可以为负，即：如果A小于V的话，就不能够执行转换）。 然而，在解读密文的过程中，百小度预支了他的智商，所以他现在不知道自己是否能够旋转石盘，打开石门，你能帮帮他吗？ Input 输入数据第一行是一个整数T，表示包含T组测试样例； 接下来是T行数据，每行有4个自然数N,M,V,K（字符含义见题目描述）； 数据范围： T<=100 N,M,V,K <= 10^8 Output 对于每组数据，请输出最少做几次能量转换才能够有足够的能量点开门； 如果无法做到，请直接输出-1。 Sample Input 4 10 3 1 2 10 2 1 2 10 9 7 3 10 10 10000 0 Sample Output 3 -1 -1 0
思路：
直接模拟，因为题目给出的数列增长速度很快（大约是指数级的）。所以一定能在很短的时间内达到目标（如果可以达到）。 除此之外，特判一下不能达到和在最开始就达到的情形。注意用long long 中间结果可能溢出整型。
代码：
1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 #include <cstdlib> 5 #include <cmath> 6 #include <algorithm> 7 #include <string> 8 #include <queue> 9 #include <stack> 10 #include <vector> 11 #include <map> 12 #include <set> 13 #include <functional> 14 #include <time.h> 15 16 using namespace std; 17 18 typedef __int64 ll; 19 20 const int INF = 1<<30; 21 22 int n, m, v, k; 23 24 void solve() { 25 if (m>=n) { 26 puts("0"); 27 return ; 28 } 29 ll t = (ll)k*(m-v); 30 if (t<=m) { 31 puts("-1"); 32 return ; 33 } 34 ll ans = 1; 35 while (t<n) { 36 t = (t-v)*k; 37 ans+=1; 38 } 39 printf("%d\n", ans); 40 } 41 42 int main() { 43 #ifdef Phantom01 44 freopen("1001.txt", "r", stdin); 45 #endif //Phanaom01 46 47 int T; 48 scanf("%d", &T); 49 50 while (T--) { 51 scanf("%d%d%d%d", &n, &m, &v, &k); 52 solve(); 53 } 54 55 return 0; 56 }
1002：
Disk Schedule Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1463 Accepted Submission(s): 189 Problem Description 有很多从磁盘读取数据的需求，包括顺序读取、随机读取。为了提高效率，需要人为安排磁盘读取。然而，在现实中，这种做法很复杂。我们考虑一个相对简单的场景。 磁盘有许多轨道，每个轨道有许多扇区，用于存储数据。当我们想在特定扇区来读取数据时，磁头需要跳转到特定的轨道、具体扇区进行读取操作。为了简单，我们假设磁头可以在某个轨道顺时针或逆时针匀速旋转，旋转一周的时间是360个单位时间。磁头也可以随意移动到某个轨道进行读取，每跳转到一个相邻轨道的时间为400个单位时间，跳转前后磁头所在扇区位置不变。一次读取数据的时间为10个单位时间，读取前后磁头所在的扇区位置不变。磁头同时只能做一件事：跳转轨道，旋转或读取。 现在，需要在磁盘读取一组数据，假设每个轨道至多有一个读取请求，这个读取的扇区是轨道上分布在 0到359内的一个整数点扇区，即轨道的某个360等分点。磁头的起始点在0轨道0扇区，此时没有数据读取。在完成所有读取后，磁头需要回到0轨道0扇区的始点位置。请问完成给定的读取所需的最小时间。 Input 输入的第一行包含一个整数M（0<M<=100），表示测试数据的组数。 对于每组测试数据，第一行包含一个整数N（0<N<=1000），表示要读取的数据的数量。之后每行包含两个整数T和S（0<T<=1000，0<= S<360），表示每个数据的磁道和扇区，磁道是按升序排列，并且没有重复。 Output 对于每组测试数据，输出一个整数，表示完成全部读取所需的时间。 Sample Input 3 1 1 10 3 1 20 3 30 5 10 2 1 10 2 11 Sample Output 830 4090 1642
思路：
动态规划。
根据题目描述，可以确定，移动的形式一定是一去一回最短，所以每个数据点有两种选择：出去的时候读取，回来的时候读取。
然后我们可以把回来的时候的读取过程逆过了，这样子就变成的有两次出去，所以我们可以枚举每次读取是在两条线中的哪一条就好了。
最后，把两条线连起来就可以得到结果。
1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 #include <cstdlib> 5 #include <cmath> 6 #include <algorithm> 7 #include <string> 8 #include <queue> 9 #include <stack> 10 #include <vector> 11 #include <map> 12 #include <set> 13 #include <functional> 14 #include <time.h> 15 16 using namespace std; 17 18 const int INF = 1<<30; 19 const int MAXN = 1011; 20 21 int a[MAXN], b[MAXN]; 22 int dp[MAXN][MAXN]; // dp[i][j] 表示 第一条线路最上面是i，第二条最上面是j的最优值 23 int n; 24 25 inline int myAbs(int x) { 26 return x>0 ? x : -x; 27 } 28 29 inline int cal(int x, int y) { //计算从第x个到第y个的时间 30 return min(myAbs(b[x]-b[y]), 360-myAbs(b[x]-b[y])) + 400*myAbs(a[x]-a[y]); 31 } 32 33 void input() { 34 scanf("%d", &n); 35 for (int i = 1; i <= n; i++) 36 scanf("%d%d", &a[i], &b[i]); 37 } 38 39 void solve() { 40 memset(dp, -1, sizeof(dp)); 41 a[0] = b[0] = 0; 42 dp[0][0] = 0; //边界 起点和终点 43 44 for (int i = 1; i <= n; i++) { 45 for (int j = 0; j < i; j++) 46 dp[i][j] = dp[j][i] = INF; 47 int cost2 = cal(i, i-1); 48 for (int j = 0; j < i; j++) { 49 if (j!=0 && j>i-2) continue; //除了出示状态， 50 int cost1 = cal(i, j); 51 //由dp[i-1][j] 可以转移到 dp[i][j] 和 dp[i-1][i] 52 dp[i][j] = min(dp[i][j], dp[i-1][j]+cost2); 53 dp[i-1][i] = min(dp[i-1][i], dp[i-1][j]+cost1); 54 //由dp[j][i-1] 可以转移到 dp[i][i-1] 和 dp[j][i] 55 dp[j][i] = min(dp[j][i], dp[j][i-1]+cost2); 56 dp[i][i-1] = min(dp[i][i-1], dp[j][i-1]+cost1); 57 } 58 } 59 60 int ans = INF; 61 for (int i = 0; i < n; i++) 62 ans = min(ans, min(dp[i][n], dp[n][i])+cal(n, i)); 63 printf("%d\n", ans+n*10); 64 } 65 66 int main() { 67 #ifdef Phantom01 68 freopen("1002.txt", "r", stdin); 69 #endif //Phantom01 70 71 int T; 72 scanf("%d", &T); 73 74 while (T--) { 75 input(); 76 solve(); 77 } 78 79 return 0; 80 }
1003：
Xor Sum Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 132768/132768 K (Java/Others) Total Submission(s): 4445 Accepted Submission(s): 652 Problem Description Zeus 和 Prometheus 做了一个游戏，Prometheus 给 Zeus 一个集合，集合中包含了N个正整数，随后 Prometheus 将向 Zeus 发起M次询问，每次询问中包含一个正整数 S ，之后 Zeus 需要在集合当中找出一个正整数 K ，使得 K 与 S 的异或结果最大。Prometheus 为了让 Zeus 看到人类的伟大，随即同意 Zeus 可以向人类求助。你能证明人类的智慧么？ Input 输入包含若干组测试数据，每组测试数据包含若干行。 输入的第一行是一个整数T（T < 10），表示共有T组数据。 每组数据的第一行输入两个正整数N，M（<1=N,M<=100000），接下来一行，包含N个正整数，代表 Zeus 的获得的集合，之后M行，每行一个正整数S，代表 Prometheus 询问的正整数。所有正整数均不超过2^32。 Output 对于每组数据，首先需要输出单独一行”Case #?:”，其中问号处应填入当前的数据组数，组数从1开始计算。 对于每个询问，输出一个正整数K，使得K与S异或值最大。 Sample Input 2 3 2 3 4 5 1 5 4 1 4 6 5 6 3 Sample Output Case #1: 4 3 Case #2: 4
思路：
把数字当做二进制，然后先找高位数字不同的，然后找低位数字不同的。
可以先排个序然后而二分，或者用字典树。注意输入可能超整型
我用的字典树，然后顺着路径找就是了。
1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 #include <cstdlib> 5 #include <cmath> 6 #include <algorithm> 7 #include <string> 8 #include <queue> 9 #include <stack> 10 #include <vector> 11 #include <map> 12 #include <set> 13 #include <functional> 14 #include <time.h> 15 16 using namespace std; 17 18 typedef __int64 ll; 19 20 const int INF = 1<<30; 21 const int MAXN = (int) 7e6+11; 22 const int MAX_SIZE = 40; 23 24 struct Node { 25 ll val; 26 int ch[2]; 27 }Trie[MAXN]; 28 int use; 29 30 ll S[MAX_SIZE]; 31 int n, m; 32 33 int New() { 34 Trie[use].val = Trie[use].ch[0] = Trie[use].ch[1] = 0; 35 return use++; 36 } 37 38 void init() { 39 use = 0; 40 New(); 41 } 42 43 inline void change(ll x) { //转换成二进制 44 for (int i = MAX_SIZE-1; i >= 0; i--) { 45 S[i] = x&1; 46 x >>= 1; 47 } 48 } 49 50 void insert(ll x) { 51 change(x); 52 53 int p = 0; 54 for (int i = 0; i < MAX_SIZE; i++) { 55 if (!Trie[p].ch[S[i]]) Trie[p].ch[S[i]] = New(); 56 p = Trie[p].ch[S[i]]; 57 } 58 Trie[p].val = x; 59 } 60 61 ll find(ll x) { 62 change(x); 63 64 int p = 0; 65 for (int i = 0; i < MAX_SIZE; i++) { 66 int now; 67 if (Trie[p].ch[S[i]^1]) p = Trie[p].ch[S[i]^1]; 68 else p = Trie[p].ch[S[i]]; 69 } 70 return Trie[p].val; 71 } 72 73 void input() { 74 init(); 75 scanf("%d%d", &n, &m); 76 for (int i = 0; i < n; i++) { 77 ll x; 78 scanf("%I64d", &x); 79 insert(x); 80 } 81 } 82 83 void solve() { 84 for (int i = 0; i < m; i++) { 85 ll x; 86 scanf("%I64d", &x); 87 printf("%I64d\n", find(x)); 88 } 89 } 90 91 int main() { 92 #ifdef Phantom01 93 freopen("1003.txt", "r", stdin); 94 #endif //Phantom01 95 96 int T; 97 scanf("%d", &T); 98 99 for (int Case = 1; Case <= T; Case++) { 100 printf("Case #%d:\n", Case); 101 input(); 102 solve(); 103 } 104 105 return 0; 106 }
1004：
Labyrinth Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1507 Accepted Submission(s): 520 Problem Description 度度熊是一只喜欢探险的熊，一次偶然落进了一个m*n矩阵的迷宫，该迷宫只能从矩阵左上角第一个方格开始走，只有走到右上角的第一个格子才算走出迷宫，每一次只能走一格，且只能向上向下向右走以前没有走过的格子，每一个格子中都有一些金币（或正或负，有可能遇到强盗拦路抢劫，度度熊身上金币可以为负，需要给强盗写欠条），度度熊刚开始时身上金币数为0，问度度熊走出迷宫时候身上最多有多少金币？ Input 输入的第一行是一个整数T（T < 200），表示共有T组数据。 每组数据的第一行输入两个正整数m，n（m<=100，n<=100）。接下来的m行，每行n个整数，分别代表相应格子中能得到金币的数量，每个整数都大于等于-100且小于等于100。 Output 对于每组数据，首先需要输出单独一行”Case #?:”，其中问号处应填入当前的数据组数，组数从1开始计算。 每组测试数据输出一行，输出一个整数，代表根据最优的打法，你走到右上角时可以获得的最大金币数目。 Sample Input 2 3 4 1 -1 1 0 2 -2 4 2 3 5 1 -90 2 2 1 1 1 1 Sample Output Case #1: 18 Case #2: 4
思路：
动态规划
以每一列作为一个阶段，求出当前阶段每一格可能达到的最大值，然后转移到下一阶段。具体详见代码。
1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 #include <cstdlib> 5 #include <cmath> 6 #include <algorithm> 7 #include <string> 8 #include <queue> 9 #include <stack> 10 #include <vector> 11 #include <map> 12 #include <set> 13 #include <functional> 14 #include <time.h> 15 16 using namespace std; 17 18 const int INF = 1<<29; 19 const int MAXN = 105; 20 21 int a[MAXN][MAXN]; 22 int dp[MAXN][MAXN]; 23 int tmp1[MAXN][MAXN]; 24 int tmp2[MAXN][MAXN]; 25 int n, m; 26 27 void print() { 28 for (int i = 0; i < n; i++) { 29 for (int j = 0; j < m; j++) 30 printf("%d ", dp[i][j]); 31 puts(""); 32 } 33 } 34 35 void input() { 36 scanf("%d%d", &n, &m); 37 for (int i = 0; i < n; i++) 38 for (int j = 0; j < m; j++) 39 scanf("%d", &a[i][j]); 40 } 41 42 void solve() { 43 for (int i = 0; i < n; i++) 44 for (int j = 0; j < m; j++) 45 dp[i][j] = -INF; 46 dp[0][0] = a[0][0]; 47 48 for (int j = 0; j < m; j++) { 49 //更新向下走以后的最值 50 for (int i = 0; i < n; i++) { 51 tmp1[i][j] = dp[i][j]; 52 if (i>0) tmp1[i][j] = max(tmp1[i][j], a[i][j]+tmp1[i-1][j]); 53 } 54 //更新向上走以后的最值 55 for (int i = n-1; i >= 0; i--) { 56 tmp2[i][j] = dp[i][j]; 57 if (i<n-1) tmp2[i][j] = max(tmp2[i][j], a[i][j]+tmp2[i+1][j]); 58 } 59 //更新当前格的最终值，及下一个的初值 60 for (int i = 0; i < n; i++) { 61 dp[i][j] = max(tmp1[i][j], tmp2[i][j]); 62 dp[i][j+1] = dp[i][j] + a[i][j+1]; 63 } 64 } 65 66 printf("%d\n", dp[0][m-1]); 67 } 68 69 int main() { 70 #ifdef Phantom01 71 freopen("1004.txt", "r", stdin); 72 #endif //Phanaom01 73 74 int T; 75 scanf("%d", &T); 76 for (int Case = 1; Case <= T; Case++) { 77 printf("Case #%d:\n", Case); 78 input(); 79 solve(); 80 } 81 82 return 0; 83 }
2014年百度之星 资格赛题解,布布扣,bubuko.com
标签：des style c class blog code
原文地址：http://www.cnblogs.com/Phantom01/p/3734091.html
