本渣清明节 闲里偷忙 做了一下codejam

水平不出意外的在投稿之后一落千丈

后两题的hidden test竟然都挂了

A. Foregone Solution

水题，稍微判断一下特殊情况(比如1000, 5000这种)就好了

  1. #include <iostream>
  2. #include <cstdio>
  3. #include <cstdlib>
  4. #include <cmath>
  5. #include <climits>
  6. #include <cstring>
  7. #include <vector>
  8. #include <list>
  9. #include <queue>
  10. #include <stack>
  11. #include <map>
  12. #include <set>
  13. #include <bitset>
  14. #include <algorithm>
  15. #include <functional>
  16. // #include <assert.h>
  17. #include <iomanip>
  18. using namespace std;
  19. const int N = 7005;
  20. const int M = 2e5 + 5;
  21. const int INF = 0x3f3f3f3f;
  22. const int MOD = 1000000007;
  23. typedef long long ll;
  25. char num[105];
  26. char a[105];
  27. char b[105];
  28. int main() {
  29.     int _;
  30.     scanf("%d", &_);
  31.     for(int cas = 1; cas <= _; ++cas) {
  32.         scanf("%s", num);
  34.         bool flag = true;
  35.         for(int i = 0, len = strlen(num); i < len; ++i) {
  36.             if(num[i] == '4') {
  37.                 a[i] = '2';
  38.                 b[i] = '2';
  39.                 flag = false;
  40.             } else {
  41.                 a[i] = num[i];
  42.                 b[i] = '0';
  43.             }
  44.         }
  46.         if(flag == true) {
  47.             int pos = -1;
  49.             for(int i = strlen(num) - 1; i >= 0; --i) {
  50.                 if(num[i] != '0') {
  51.                     pos = i;
  52.                     // if(num[i] == '1') {
  53.                     //     hasOne = true;
  54.                     // }
  55.                     break;
  56.                 }
  57.             }
  58.             int hasOne = false;
  59.             for(int i = 0, len = strlen(num); i < len; ++i) {
  60.                 if(i < pos) {
  61.                     a[i] = num[i];
  62.                     b[i] = '0';
  63.                 } else if(i == pos) {
  64.                     if(num[i] == '5') {
  65.                         a[i] = '3';
  66.                         b[i] = '2';
  67.                     } else if(num[i] == '1' && i != strlen(num) - 1) {
  68.                         a[i] = '0';
  69.                         b[i] = '0';
  70.                         hasOne = true;
  71.                     } else {
  72.                         a[i] = num[i] - 1;
  73.                         b[i] = '1';
  74.                     }
  75.                 } else {
  76.                     if(hasOne) {
  77.                         a[i] = '9';
  78.                         b[i] = (i == strlen(num) - 1) ? '1' :'0';
  79.                     } else {
  80.                         a[i] = num[i];
  81.                         b[i] = '0';
  82.                     }
  83.                 }
  84.             }
  85.         }
  87.         printf("Case #%d: ", cas);
  88.         for(int i = 0, len = strlen(num), flag = true; i < len; ++i) {
  89.             if(a[i] == '0' && flag) {
  90.             } else {
  91.                 flag = false;
  92.                 printf("%c", a[i]);
  93.             }
  94.         }
  95.         printf(" ");
  96.         for(int i = 0, len = strlen(num), flag = true; i < len; ++i) {
  97.             if(b[i] == '0' && flag) {
  98.             } else {
  99.                 flag = false;
  100.                 printf("%c", b[i]);
  101.             }
  102.         }
  103.         printf("\n");
  105.     }
  106.     return 0;
  107. }

B. You Can Go Your Own Way

水题，直接和她反着来就好了

  1. #include <iostream>
  2. #include <cstdio>
  3. #include <cstdlib>
  4. #include <cmath>
  5. #include <climits>
  6. #include <cstring>
  7. #include <vector>
  8. #include <list>
  9. #include <queue>
  10. #include <stack>
  11. #include <map>
  12. #include <set>
  13. #include <bitset>
  14. #include <algorithm>
  15. #include <functional>
  16. // #include <assert.h>
  17. #include <iomanip>
  18. using namespace std;
  19. const int N = 7005;
  20. const int M = 2e5 + 5;
  21. const int INF = 0x3f3f3f3f;
  22. const int MOD = 1000000007;
  23. typedef long long ll;
  25. char seq[100005];
  26. char result[100005];
  27. int main() {
  28.     int _;
  29.     scanf("%d", &_);
  30.     for(int cas = 1; cas <= _; ++cas) {
  31.         int n;
  32.         scanf("%d %s", &n, seq);
  33.         for(int i = 0, len = strlen(seq); i < len; ++i) {
  34.             if(seq[i] == 'S')
  35.                 result[i] = 'E';
  36.             else
  37.                 result[i] = 'S';
  38.         }
  40.         printf("Case #%d: ", cas);
  41.         for(int i = 0, len = strlen(seq); i < len; ++i) {
  42.             printf("%c", result[i]);
  43.         }
  44.         printf("\n");
  46.     }
  47.     return 0;
  48. }

C. Cryptopangrams

大家都知道求下相邻的数的gcd，然后去重，排序

有个小坑就是，序列当中可能相邻的数是相同的，也就意味着有原始密码有a,b,a这种。需要找到一个相邻的数不相同的，然后反推其他的所有

其次就是大数，c++模版不好找，不如写java, python

  1. import java.io.*;
  2. import java.util.*;
  3. import java.math.*;
  5. public class Solution {
  6.     Scanner in = new Scanner(new BufferedInputStream(System.in));
  7.     PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
  8.     BigInteger seq[] = new BigInteger[105];
  9.     BigInteger prime[] = new BigInteger[105];
  10.     //    BigInteger num[] = new BigInteger[105];
  11.     int lower_bound(BigInteger[] nums, int begin, int end, BigInteger value) {
  12.         while (begin < end) {
  13.             int mid = begin + (end - begin) / 2;
  14.             if (nums[mid].compareTo(value) == -1) {
  15.                 begin = mid + 1;
  16.             } else {
  17.                 end = mid;
  18.             }
  19.         }
  20.         return begin;
  21.     }
  22.     void solve() {
  23.         int casNum;
  24.         casNum = in.nextInt();
  25.         for(int cas = 1; cas <= casNum; ++cas) {
  26.             BigInteger n;
  27.             int l;
  28.             n = in.nextBigInteger(); l = in.nextInt();
  29.             for(int i = 0; i < l; ++i) {
  30.                 seq[i] = in.nextBigInteger();
  31.             }
  33.             int pos = -1;
  34.             for(int i = 1; i < l; ++i) {
  35.                 if(seq[i].equals(seq[i-1]) == false) {
  36.                     prime[i] = seq[i].gcd(seq[i-1]);
  37.                     pos = i;
  38.                     break;
  39.                 }
  40.             }
  42.             for(int i = pos - 1; i >= 0; --i) {
  43.                 prime[i] = seq[i].divide(prime[i + 1]);
  44.             }
  45.             for(int i = pos + 1; i <= l; ++i) {
  46.                 prime[i] = seq[i-1].divide(prime[i-1]);
  47.             }
  49.             List<BigInteger> num=new ArrayList<>();
  50.             for(int i = 0; i <= l; ++i) {
  51.                 num.add(prime[i]);
  52.             }
  53.             Set<BigInteger> uniqueGas = new HashSet<BigInteger>(num);
  54. //            out.println(uniqueGas.size());
  55. //            for(BigInteger i : uniqueGas) {
  56. //                out.println(i);
  57. //            }
  58.             BigInteger[] result = uniqueGas.toArray(new BigInteger[0]);
  59.             Arrays.sort(result, 0, uniqueGas.size());
  60.             assert(uniqueGas.size() == 26);
  61.             // printf("%d\n", (int)num.size());
  62.             // for(int i = 0, len = num.size(); i < len; ++i) printf("%lld ", num[i]); printf("\n");
  63.             out.printf("Case #%d: ", cas);
  65.             for(int i = 0; i <= l; ++i) {
  66.                 int tt = lower_bound(result,0, uniqueGas.size(), prime[i]);
  67.                 out.printf("%c", tt + 'A');
  68.             }
  69.             out.printf("\n");
  70.         }
  71.         out.flush();
  72.     }
  73.     public static void main(String args[]) {
  74.         new Solution ().solve();
  76.     }
  77. }

D. Dat Bae

如果B没有小于等于15的限制的话，本渣觉得需要10次查询，这也是本渣的解法

不断二分01查询，比如0011, 0101这样查，就能最后判断出来每个位置在不在

  1. #include <iostream>
  2. #include <cstdio>
  3. #include <cstdlib>
  4. #include <cmath>
  5. #include <climits>
  6. #include <cstring>
  7. #include <vector>
  8. #include <list>
  9. #include <queue>
  10. #include <stack>
  11. #include <map>
  12. #include <set>
  13. #include <bitset>
  14. #include <algorithm>
  15. #include <functional>
  16. #include <assert.h>
  17. #include <iomanip>
  18. using namespace std;
  19. const int N = 7005;
  20. const int M = 2e5 + 5;
  21. const int INF = 0x3f3f3f3f;
  22. const int MOD = 1000000007;
  23. typedef long long ll;
  25. vector<pair<int, int> > prepare;
  26. vector<pair<int, int> > solve;
  27. vector<int> preClip;
  28. vector<int> solveClip;
  29. int result[2005];
  30. char answer[2005];
  31. int main() {
  32.     int _;
  33.     scanf("%d", &_);
  34.     for(int cas = 1; cas <= _; ++cas) {
  35.         int n, b, f;
  36.         scanf("%d %d %d", &n, &b, &f);
  37.         prepare.clear();
  38.         preClip.clear();
  39.         prepare.push_back(make_pair(1, n));
  40.         preClip.push_back(n - b);
  42.         while(1) {
  43.             solveClip.clear();
  44.             solve.clear();
  45.             int flag = false;
  46.             int maxx = -1;
  47.             for(int i = 0, len = prepare.size(); i < len; ++i) {
  48.                 int start = prepare[i].first; int end = prepare[i].second;
  49.                 // if(end == start) {
  50.                 //     solve.push_back(make_pair(start, end));
  51.                 // } else {
  52.                     int mid = (start + end) / 2;
  53.                     solve.push_back(make_pair(start, mid));
  54.                     solve.push_back(make_pair(mid + 1, end));
  55.                 // }
  56.                 maxx = max(maxx, end - start);
  57.             }
  58.             if(maxx == 1) flag = true;
  60.             for(int i = 0, len = solve.size(); i < len; ++i) {
  61.                 int start = solve[i].first; int end = solve[i].second;
  62.                 for(int j = start; j <= end; ++j) {
  63.                     printf("%d", (i % 2 == 0) ? 0 : 1);
  64.                 }
  65.             }
  66.             printf("\n");
  67.             fflush(stdout);
  68.             scanf("%s", answer);
  69.             for(int i = 0, len = preClip.size(), pre = 0; i < len; ++i) {
  70.                 int pos = pre + preClip[i];
  71.                 for(int j = pre, endJ = pre + preClip[i]; j < endJ; ++j) {
  72.                     if(answer[j] == '1') {
  73.                         pos = j;
  74.                         break;
  75.                     }
  76.                 }
  77.                 solveClip.push_back(pos - pre);
  78.                 solveClip.push_back(preClip[i] - pos + pre);
  79.                 pre += preClip[i];
  80.             }
  82.             if(flag == true) break;
  84.             // assert(solve.size() == solveClip.size());
  85.             // for(int i = 0, len = solve.size(); i < len; ++i) {
  86.             //     int start = solve[i].first; int end = solve[i].second; int val = solveClip[i];
  87.             //     printf("%d %d %d: ", start, end, val);
  88.             // } printf("\n");
  90.             prepare.swap(solve);
  91.             preClip.swap(solveClip);
  92.         }
  94.         assert(solve.size() == solveClip.size());
  96.         for(int i = 0, len = solve.size(); i < len; ++i) {
  97.             int start = solve[i].first; int end = solve[i].second; int val = solveClip[i];
  98.             if(start == end) {
  99.                 if(val == 1) {
  100.                     result[start] = 1;
  101.                 } else {
  102.                     result[start] = 0;
  103.                 }
  104.             }
  105.         }
  106.         for(int i = 1, fir = true; i <= n; ++i) {
  107.             if(result[i] == 0) {
  108.                 if(fir) fir = false;
  109.                 else printf(" ");
  110.                 printf("%d", i - 1);
  111.             }
  112.         }
  113.         printf("\n");
  114.         fflush(stdout);
  116.         int basa;
  117.         scanf("%d", &basa);
  118.     }
  119.     return 0;
  120. }
  122. /*
  123. 1000
  124. 5 2 10
  125. answer(0 3)
  126. 2 1 10
  127. answer(0)
  129. */

但是如果只是5次查询，这样不行。反过来通过1，2，4，8为界的查询方式，判断一个16个数的组的borken情况。

如下所示

0101010101010101

0011001100110011

0000111100001111

0000000011111111

可以每16个数一个组，因为我们知道最多15个broken，每组必会有数保留，那么我们就可以判断出每个数是在哪个组当中的。贴下别人的代码

  1. #include <iostream>
  2. #include <cstdio>
  3. #include <cstdlib>
  4. #include <cmath>
  5. #include <climits>
  6. #include <cstring>
  7. #include <vector>
  8. #include <list>
  9. #include <queue>
  10. #include <stack>
  11. #include <map>
  12. #include <set>
  13. #include <bitset>
  14. #include <algorithm>
  15. #include <functional>
  16. #include <assert.h>
  17. #include <iomanip>
  18. using namespace std;
  19. const int N = 7005;
  20. const int M = 2e5 + 5;
  21. const int INF = 0x3f3f3f3f;
  22. const int MOD = 1000000007;
  23. typedef long long ll;
  25. void solve(){
  26. 	int F = 4;
  27. 	int n, b, fake_f;
  28. 	cin >> n >> b >> fake_f;
  29. 	// assert(fake_f >= F);
  30. 	for(int f = 0; f < F; f++){
  31. 		string g;
  32. 		for(int i = 0; i < n; i++){
  33. 			g += (char)('0' + ((i >> f) & 1));
  34. 		}
  35. 		cout << g << '\n' << flush;
  36. 	}
  37. 	vector<int> answers(n-b);
  38. 	for(int f = 0; f < F; f++){
  39. 		string res;
  40. 		cin >> res;
  41. 		for(int i = 0; i < n-b; i++){
  42. 			answers[i] ^= (res[i] - '0') << f;
  43. 		}
  44.         // for(int i = 0; i < n - b; ++i) {
  45.         //     printf("%d ", answers[i]);
  46.         // } printf("\n");
  47. 	}
  48. 	vector<int> broken;
  49. 	int z = 0;
  50. 	for(int i = 0; i < n-b; i++){
  51. 		while((z & 15) != answers[i]){
  52. 			cout << z << ' ';
  53. 			z++;
  54. 		}
  55. 		z++;
  56. 	}
  57. 	while(z < n){
  58. 		cout << z << ' ';
  59. 		z++;
  60. 	}
  61. 	cout << '\n';
  62. 	cout << flush;
  63. 	int res;
  64. 	cin >> res;
  65. }
  67. int main(){
  68. 	int T;
  69. 	cin >> T;
  70. 	for(int t = 1; t <= T; t++){
  71. 		solve();
  72. 	}
  73. }
  75. /*
  76. 1000
  77. 5 2 10
  79. 01010
  80. 00110
  81. 00001
  82. 00000
  83. 00000
  84. 100
  85. 010
  86. 001
  87. 000
  88. 000
  89. answer(0 3)
  90. 000
  91. 010
  92. 001
  93. 000
  94. 000
  95. answer(0 3)
  97. 2 1 10
  98. answer(0)
  100. */

Codejam Qualification Round 2019的更多相关文章

  1. Google Code Jam Africa 2010 Qualification Round Problem B. Reverse Words

    Google Code Jam Africa 2010 Qualification Round Problem B. Reverse Words https://code.google.com/cod ...

  2. Google Code Jam Africa 2010 Qualification Round Problem A. Store Credit

    Google Code Jam Qualification Round Africa 2010 Problem A. Store Credit https://code.google.com/code ...

  3. Facebook Hacker Cup 2014 Qualification Round 竞赛试题 Square Detector 解题报告

    Facebook Hacker Cup 2014 Qualification Round比赛Square Detector题的解题报告.单击这里打开题目链接(国内访问需要那个,你懂的). 原题如下: ...

  4. DP VK Cup 2012 Qualification Round D. Palindrome pairs

    题目地址:http://blog.csdn.net/shiyuankongbu/article/details/10004443 /* 题意:在i前面找回文子串,在i后面找回文子串相互配对,问有几对 ...

  5. Facebook Hacker Cup 2014 Qualification Round

    2014 Qualification Round Solutions 2013年11月25日下午 1:34 ...最简单的一题又有bug...自以为是真是很厉害! 1. Square Detector ...

  6. [C++]Store Credit——Google Code Jam Qualification Round Africa 2010

    Google Code Jam Qualification Round Africa 2010 的第一题,很简单. Problem You receive a credit C at a local ...

  7. dp - Google Code jam Qualification Round 2015 --- Problem B. Infinite House of Pancakes

    Problem B. Infinite House of Pancakes Problem's Link:   https://code.google.com/codejam/contest/6224 ...

  8. Google Code jam Qualification Round 2015 --- Problem A. Standing Ovation

    Problem A. Standing Ovation Problem's Link:   https://code.google.com/codejam/contest/6224486/dashbo ...

  9. Google Code Jam 2009 Qualification Round Problem C. Welcome to Code Jam

    本题的 Large dataset 本人尚未解决. https://code.google.com/codejam/contest/90101/dashboard#s=p2 Problem So yo ...

随机推荐

  1. 模拟prompt

    <!DOCTYPE html"> <meta http-equiv="Content-Type" content="text/html; ch ...

  2. [翻译] 提升树算法的介绍（Introduction to Boosted Trees）

    [翻译] 提升树算法的介绍(Introduction to Boosted Trees) 1. 有监督学习的要素 XGBoost 适用于有监督学习问题.在此类问题中,我们使用多特征的训练数据集 \(x ...

  3. 元素视差方向移动jQuery插件-类似github 404页面效果

    原文地址:http://www.xuanfengge.com/shake.html 前言: 视差滚动,大家也许并不陌生.但是对于视差方向移动,你是否有见过效果呢?看官请进来瞧瞧~ demo : 轩枫阁 ...

  4. IIS7.5全站301跳转，内页+带参数url，这才是真正的全站跳转

    说好的转型安全领域,可是我还是忍不住要给大家分享这个教程.因为这个问题很常见,大部分人都遇到了(可能你没注意),困扰了我很久,相信这是一篇真正适合你的IIS301跳转教程. 背景 说到301跳转,作为 ...

  5. day4-课堂代码

    # ---------------------------------------------------------------------- # def my_function1(name, ad ...

  6. DFT scan chain

    现代集成电路的制造工艺越来越先进,但是在生产过程中的制造缺陷也越来越难以控制,甚至一颗小小的PM2.5就可能导致芯片报废,为了能有效的检测出生产中出现的废片,需要用到扫描链测试(scan chain) ...

  7. 理解javascript观察者模式(订阅者与发布者)

    什么是观察者模式? 观察者模式又叫做发布订阅模式,它定义了一种一对多的关系,让多个观察者对象同时监听某一个主题对象,这个主题对象的状态发生改变时就会通知所有观察着对象.它是由两类对象组成,主题和观察者 ...

  8. JBOSS安装与配置搭建本地项目环境(方便前端开发调式)

    JBOSS安装与配置搭建本地项目环境  什么是JBOSS? JBOSS是EJB的服务器,就像Tomcat是JSP服务器一样,就是服务器的一种. 环境搭建如下: 一:首先安装JDK,配置环境变量(PAT ...

  9. Android 使用正则表达式验证身份证号是否符合规则

    我国当前的身份证号分为三种: 一.15位身份证号 二.18位身份证号(前17位位数字,最后一位为字母x) 三.18为身份证号(18位都是数字) 具体验证请参考下面代码: /** * 验证身份证号是否符 ...

  10. odoo明细表汇总数据

    一.在主表中#改动地方 总结算金额 求和:def _get_subtotal2(self, cr, uid, ids, field_name, arg, context=None): # 初始化 re ...