Speed Typing

题意概述

给出两个字符串I和P，问能否通过删除P中若干个字符得到I？如果能的话，需要删除字符的个数是多少？

数据规模

\[1≤|I|,|P|≤10^5
\]

双指针

设置两个指针i和j分别指向I和P的第一个字符，滑动指针j，如果j指向的字符与i指向的字符相同，则让i向后滑动一个字符，当i滑动到I字符串末尾或j滑动到P字符串末尾后即可结束循环。如果i滑动到I字符串末尾，则说明可以通过删除P中若干个字符得到I，那么删除的字符个数为\(|P|-|I|\)；反之则不能。

复杂度

  • 时间复杂度为\(O(max(|I|,|P|))\)。
  • 空间复杂度为\(O(1)\)。

C++代码

  1. #include <bits/stdc++.h>
  2. using namespace std;
  3. using gg = long long;
  4. #define rep(i, a, b, c) for (gg i = (a); i <= (b); i += (c))
  5. #define rrep(i, a, b, c) for (gg i = (a); i >= (b); i -= (c))
  6. constexpr gg MAX = 1e6 + 5;
  7. constexpr gg mod = 1e9 + 7;
  8. constexpr gg INF = 4e18;
  9. constexpr double eps = 1e-12;
  10. gg ti, ni, mi, ki, di, pi, xi, yi;
  11. gg up(gg n, gg m) { return n >= 0 ? (n + m - 1) / m : n / m; }
  12. gg down(gg n, gg m) { return n >= 0 ? n / m : (n - m + 1) / m; }
  13. //! ti; MAX; mod; 边界
  14. void solve() {
  15.     string s1, s2;
  16.     cin >> s1 >> s2;
  17.     gg i = 0, j = 0;
  18.     for (; i < s1.size() and j < s2.size(); ++i, ++j) {
  19.         while (j < s2.size() and s1[i] != s2[j]) {
  20.             ++j;
  21.         }
  22.         if (j == s2.size()) {
  23.             break;
  24.         }
  25.     }
  26.     i == s1.size() ? cout << s2.size() - s1.size() : cout << "IMPOSSIBLE";
  27. }
  28. int main() {
  29.     ios::sync_with_stdio(false);
  30.     cin.tie(0);
  31.     ti = 1;
  32.     cin >> ti;
  33.     for (gg ii = 1; ii <= ti; ++ii) {
  34.         cout << "Case #" << ii << ": ";
  35.         solve();
  36.         cout << "\n";
  37.     }
  38.     return 0;
  39. }

Challenge Nine

题意概述

给定一个正整数\(N\)，在给定的数字\(N\)的任意位置插入一个[0,9]之间的数字，得到一个不带前导零的新的数字，需要保证这个新的数字是9的倍数。问能构造出的最小的数字是多少？

数据规模

\[1≤N≤10^{123456}
\]

贪心

由于给出的数字非常大，需要用字符串读入。易知一个数字是9的倍数的充要条件是该数各位上的数字之和也是9的倍数。因此，先计算出读取的字符串各位上的数字之和sum，遍历0~9这10个数字，假设当前遍历到的数字是i，如果i与sum之和是9的倍数，说明插入i能够保证新数字是9的倍数。接着从N的高位向低位遍历，假设当前遍历到的位上的数字是j，如果i<j，则将i插入到j之前可以得到最小的数字（想一想为什么？）。

复杂度

  • 时间复杂度为\(O(n)\)。
  • 空间复杂度为\(O(n)\)。

其中\(n\)指的是数字N的位数。

C++代码

  1. #include <bits/stdc++.h>
  2. using namespace std;
  3. using gg = long long;
  4. #define rep(i, a, b, c) for (gg i = (a); i <= (b); i += (c))
  5. #define rrep(i, a, b, c) for (gg i = (a); i >= (b); i -= (c))
  6. constexpr gg MAX = 1e6 + 5;
  7. constexpr gg mod = 1e9 + 7;
  8. constexpr gg INF = 4e18;
  9. constexpr double eps = 1e-12;
  10. gg ti, ni, mi, ki, di, pi, xi, yi;
  11. gg up(gg n, gg m) { return n >= 0 ? (n + m - 1) / m : n / m; }
  12. gg down(gg n, gg m) { return n >= 0 ? n / m : (n - m + 1) / m; }
  13. //! ti; MAX; mod; 边界
  14. void solve() {
  15.     string n;
  16.     cin >> n;
  17.     gg m = n.size(), sum = 0;
  18.     array<gg, 2> ans{m + 1, 10};
  19.     for (char c : n) {
  20.         sum += c - '0';
  21.     }
  22.     n.push_back(10 + '0');
  23.     rep(i, 0, 9, 1) {
  24.         if ((i + sum) % 9 == 0) {
  25.             rep(j, 0, m, 1) {
  26.                 if (n[j] - '0' > i and (j > 0 or i != 0) and ans[0] > j) {
  27.                     ans = {j, i};
  28.                     break;
  29.                 }
  30.             }
  31.         }
  32.     }
  33.     n.pop_back();
  34.     cout << n.substr(0, ans[0]) << ans[1] << n.substr(ans[0]);
  35. }
  36. int main() {
  37.     ios::sync_with_stdio(false);
  38.     cin.tie(0);
  39.     ti = 1;
  40.     cin >> ti;
  41.     for (gg ii = 1; ii <= ti; ++ii) {
  42.         cout << "Case #" << ii << ": ";
  43.         solve();
  44.         cout << "\n";
  45.     }
  46.     return 0;
  47. }

Palindrome Free Strings

题意概述

给出一个长度为\(N\)的只包含0、1和?构成的字符串S，可以随机用0、1替换掉字符串S中所有的?，问能否找到一种替换方法，使得所得到的串没有长度大于等于5的回文子串。

数据规模

\[1<=N<=5\times 10^4
\]

动态规划

首先需要注意到，如果字符串S中包含长度为\(n(n>2)\)的回文子串，那么将该回文子串首尾两个字符，那么得到的长度为\(n-2\)的子串必然也是回文的，因此，可以得到结论：如果S中不包含长度为5的回文子串，那么S中必然也不包含长度为\(5+2k(k>0)\)的回文子串；如果S中不包含长度为6的回文子串，那么S中必然也不包含长度为\(6+2k(k>0)\)的回文子串。因此，只要能够找到一种替换方法使得S不包含长度为5和6的回文子串，那么S中必然也没有长度大于等于5的回文子串。

一种暴力的方法，是通过递归的方法将S中的字符?逐个替换为0或1，并验证得到的字符串中是否存在长度为5或6的回文子串，时间复杂度为\(O(n\cdot 2^n)\)，这种方法能够通过小数据。下面主要介绍通过大数据的方法。

显然，暴力方法的时间复杂度为指数级，可以通过动态规划将时间复杂度降低到多项式级别。先进行分类讨论：如果S长度小于5，那么该字符串无论怎么替换?字符，都可以满足要求，直接输出POSSIBLE即可；如果S长度为5，那么可以暴力枚举所有可能得到的替换后的字符串，并验证该字符串是否为回文串即可；下面主要讨论S长度大于5的情况。

设\(dp[i]\)表示以S的前i个字符能否找到一种替换方法保证没有长度大于等于5的回文子串。由于要验证是否包含长度为6的回文子串，那么在每次添加新的字符S[i]时，S[i]能否构成长度为6的回文子串与S[i]前面的5个字符S[i-5],S[i-4],S[i-3],S[i-2],S[i-1]有关，因此，可以为S[i]的前5个字符标记一个状态，由于每个字符的取值只有0和1两种，因此状态总数为\(2^5\)。针对字符S[i]，暴力枚举以S[i]结尾的长度为6的子串的可能替换结果字符串j，如果j包含长度为5或6的回文子串，则不符合题目要求；否则\(dp[i][j]=dp[i-1][j']\)，其中\(j'=S[i-6]+j[:5]\)。具体实现可参考代码。

复杂度

  • 时间复杂度为\(O(2^K\cdot N)\)。
  • 空间复杂度为\(O(2^K\cdot N)\)。

其中\(K=5\)。

C++代码

  1. #include <bits/stdc++.h>
  2. using namespace std;
  3. using gg = long long;
  4. #define rep(i, a, b, c) for (gg i = (a); i <= (b); i += (c))
  5. #define rrep(i, a, b, c) for (gg i = (a); i >= (b); i -= (c))
  6. constexpr gg MAX = 1e5 + 5;
  7. constexpr gg MAX2 = 70;
  8. constexpr gg mod = 1e9 + 7;
  9. constexpr gg INF = 4e18;
  10. constexpr double eps = 1e-12;
  11. gg ti, ni, mi, ki, di, pi, xi, yi;
  12. gg up(gg n, gg m) { return n >= 0 ? (n + m - 1) / m : n / m; }
  13. gg down(gg n, gg m) { return n >= 0 ? n / m : (n - m + 1) / m; }
  14. //! ti; MAX; mod; 边界
  15. bool dp[MAX][MAX2];
  16. string s;
  17. void dfs(gg p, gg r, string cur, vector<string>& v) {
  18.     if (p > r) {
  19.         v.push_back(cur);
  20.         return;
  21.     }
  22.     if (s[p] != '1') {
  23.         dfs(p + 1, r, cur + "0", v);
  24.     }
  25.     if (s[p] != '0') {
  26.         dfs(p + 1, r, cur + "1", v);
  27.     }
  28. }
  29. bool isPalic(const string& s) { return equal(s.begin(), s.end(), s.rbegin()); }
  30. void solve() {
  31.     cin >> ni >> s;
  32.     if (ni <= 4) {
  33.         cout << "POSSIBLE";
  34.     } else if (ni == 5) {
  35.         vector<string> v;
  36.         dfs(0, 4, "", v);
  37.         bool ans = all_of(v.begin(), v.end(), isPalic);
  38.         cout << (ans ? "IMPOSSIBLE" : "POSSIBLE");
  39.     } else {
  40.         bool ans = false;
  41.         rep(i, 5, ni - 1, 1) {
  42.             vector<string> v;
  43.             dfs(i - 5, i, "", v);
  44.             for (string& k : v) {
  45.                 gg cur = stoll(k, 0, 2);
  46.                 dp[i][cur] = not(isPalic(k) or isPalic(k.substr(0, 5)) or isPalic(k.substr(1, 5)));
  47.                 if (i >= 6) {
  48.                     bool res = false;
  49.                     if (s[i - 6] != '1') {
  50.                         res = res or dp[i - 1][stoll("0" + k.substr(0, 5), 0, 2)];
  51.                     }
  52.                     if (s[i - 6] != '0') {
  53.                         res = res or dp[i - 1][stoll("1" + k.substr(0, 5), 0, 2)];
  54.                     }
  55.                     dp[i][cur] = dp[i][cur] and res;
  56.                 }
  57.                 if (i == ni - 1) {
  58.                     ans = ans or dp[i][cur];
  59.                 }
  60.             }
  61.         }
  62.         cout << (ans ? "POSSIBLE" : "IMPOSSIBLE");
  63.     }
  64. }
  65. int main() {
  66.     ios::sync_with_stdio(false);
  67.     cin.tie(0);
  68.     ti = 1;
  69.     cin >> ti;
  70.     for (gg ii = 1; ii <= ti; ++ii) {
  71.         cout << "Case #" << ii << ": ";
  72.         solve();
  73.         cout << "\n";
  74.     }
  75.     return 0;
  76. }

Interesting Integers

题意概述

如果一个整数的所有数字的乘积能被所有数字的和整除，就称这个整数为有趣的。给出两个整数\(A\)和\(B\)，找出\([A,B]\)之间有趣的整数个数。

数据规模

\[1≤A≤B≤10^5（小数据）
\]

算法设计

目前只会解小数据，大数据的解法可参考Google Kick Start 2022 Round A 题解。通过枚举\([A,B]\)之间的数字，暴力判断组成该整数的所有数字的乘积能能否被所有数字的和整除即可。

复杂度

  • 时间复杂度为\(O(n)\)。
  • 空间复杂度为\(O(n)\)。

其中\(n=B-A+1\)。

C++代码

  1. #include <bits/stdc++.h>
  2. using namespace std;
  3. using gg = long long;
  4. #define rep(i, a, b, c) for (gg i = (a); i <= (b); i += (c))
  5. #define rrep(i, a, b, c) for (gg i = (a); i >= (b); i -= (c))
  6. constexpr gg MAX = 1e5 + 5;
  7. constexpr gg MAX2 = 70;
  8. constexpr gg mod = 1e9 + 7;
  9. constexpr gg INF = 4e18;
  10. constexpr double eps = 1e-12;
  11. gg ti, ni, mi, ki, di, pi, xi, yi;
  12. gg up(gg n, gg m) { return n >= 0 ? (n + m - 1) / m : n / m; }
  13. gg down(gg n, gg m) { return n >= 0 ? n / m : (n - m + 1) / m; }
  14. //! ti; MAX; mod; 边界
  15. bool func(gg n) {
  16.     gg s = 0, p = 1;
  17.     while (n > 0) {
  18.         s += n % 10;
  19.         p *= n % 10;
  20.         n /= 10;
  21.     }
  22.     return p % s == 0;
  23. }
  24. void solve() {
  25.     cin >> xi >> yi;
  26.     gg ans = 0;
  27.     rep(i, xi, yi, 1) {
  28.         if (func(i)) {
  29.             ++ans;
  30.         }
  31.     }
  32.     cout << ans;
  33. }
  34. int main() {
  35.     ios::sync_with_stdio(false);
  36.     cin.tie(0);
  37.     ti = 1;
  38.     cin >> ti;
  39.     for (gg ii = 1; ii <= ti; ++ii) {
  40.         cout << "Case #" << ii << ": ";
  41.         solve();
  42.         cout << "\n";
  43.     }
  44.     return 0;
  45. }

Google kickstart 2022 Round A题解的更多相关文章

  1. google kickstart 2018 round D A Candies

    思路: 对于small数据,由于求和及奇数数量两个限制条件均满足区间单调性,可以直接使用尺取法(滑动窗口法)求解. 对于large数据,奇数数量依然是满足区间单调性的.首先使用尺取法,找到所有满足奇数 ...

  2. Codeforces Round #556 题解

    Codeforces Round #556 题解 Div.2 A Stock Arbitraging 傻逼题 Div.2 B Tiling Challenge 傻逼题 Div.1 A Prefix S ...

  3. LibreOJ β Round #2 题解

    LibreOJ β Round #2 题解 模拟只会猜题意 题目: 给定一个长为 \(n\) 的序列,有 \(m\) 次询问,每次问所有长度大于 \(x\) 的区间的元素和的最大值. \(1 \leq ...

  4. Google Kickstart在线测试规则以及注意事项

    谷歌招聘在如火如荼的进行中,进谷歌都需要经过谷歌kickstart在线测试,然后过了之后还有五轮的面试- -.好吧毕竟你待遇高,你强你有理.. 下面介绍一下进谷歌的第一关google kickstar ...

  5. Codeforces Round #569 题解

    Codeforces Round #569 题解 CF1179A Valeriy and Deque 有一个双端队列,每次取队首两个值,将较小值移动到队尾,较大值位置不变.多组询问求第\(m\)次操作 ...

  6. Codeforces Round #557 题解【更完了】

    Codeforces Round #557 题解 掉分快乐 CF1161A Hide and Seek Alice和Bob在玩捉♂迷♂藏,有\(n\)个格子,Bob会检查\(k\)次,第\(i\)次检 ...

  7. CFEducational Codeforces Round 66题解报告

    CFEducational Codeforces Round 66题解报告 感觉丧失了唯一一次能在CF上超过wqy的机会QAQ A 不管 B 不能直接累计乘法打\(tag\),要直接跳 C 考虑二分第 ...

  8. Google Kick Start Round G 2019

    Google Kick Start Round G 2019 Book Reading 暴力,没啥好说的 #include<bits/stdc++.h> using namespace s ...

  9. PKUSC 2022 口胡题解

    \(PKUSC\ 2022\)口胡题解 为了更好的在考试中拿分,我准备学习基础日麻知识(为什么每年都考麻将 啊啊啊) 首先\(STO\)吉老师\(ORZ,\)真的学到了好多 观察标签发现,这套题覆盖知 ...

随机推荐

  1. java对xml文件的操作

    xml文件格式(示例): <?xml version="1.0" encoding="UTF-8"?> <root> <Funct ...

  2. loj6077. 「2017 山东一轮集训 Day7」逆序对

    题目描述: loj 题解: 容斥+生成函数. 考虑加入的第$i$个元素对结果的贡献是$[0,i-1]$,我们可以列出生成函数. 长这样:$(1)*(1+x)*(1+x+x^2)*--*(1+x+x^2 ...

  3. jdr挖的大坑

    计数问题小结 很多计数问题在直接拆分计算贡献时都会出现不容易直接表示的情况.在解决这些问题时,往往需要解决一些子问题方案数的递推, 再套用组合数或者分块计算来降低难度或时间复杂度,这里给出几种递推方法 ...

  4. MySQL 面试题MySQL 中有哪几种锁？

    1.表级锁:开销小,加锁快:不会出现死锁:锁定粒度大,发生锁冲突的概率最 高,并发度最低. 2.行级锁:开销大,加锁慢:会出现死锁:锁定粒度最小,发生锁冲突的概率最 低,并发度也最高. 3.页面锁:开 ...

  5. 什么是Spring IOC 容器？

    Spring IOC 负责创建对象,管理对象(通过依赖注入(DI),装配对象,配置对象,并且管理这些对象的整个生命周期.

  6. jvm-learning-类加载器分类

    public class ClassLoaderTest { public static void main(String[] args) { //获取系统类加载器 ClassLoader syste ...

  7. Postgres数据库知识点

    1.批量插入: test_list = []for i in range(100): test_list.append(models.Testmodel(name=i, message="{ ...

  8. 以太网在汽车行业中的挑战——灵活的接口及软件使ECU开发不再复杂

    以太网在汽车行业中的挑战--灵活的接口及软件使ECU开发不再复杂 以太网将会在一批新车型中作为一个车载系统网络使用.因此,下一步就是以太网和现有汽车网络技术的集成,包括:CAN.FlexRay.LIN ...

  9. 专家PID

    前面我们讨论了经典的数字PID控制算法及其常见的改进与补偿算法,基本已经覆盖了无模型和简单模型PID控制经典算法的大部.再接下来的我们将讨论智能PID控制,智能PID控制不同于常规意义下的智能控制,是 ...

  10. IDEA安装配置Scala环境

    这里有详细步骤:windows上 IntelliJ IDEA安装scala环境 详细 初学