Codeforces Round 801 (Div. 2) Tree Queries (Hard Version)算法本质思维题目大意给定一颗树（边权默认1），其存在一个开局固定但是玩家不知道的点称之为终点。在这个游戏中，玩家可有进行询问：每次询问玩家给出某点x，系统会回答终点与x点的距离游戏目标是完成某次询问后说出终点位置。玩家总是希望用最少的次数搞定游戏，在游戏开始前，Alice问玩家至多需要几次询问。输出至多询问次数即可。思路推演首先我们需要搞定游戏规则。先从简单的开始模拟——一条链。显然如果我们询问链的某个端点，只需要一次就可以判断终点位置了，这也给了一个trick——询问总是在叶节点。然后可以从爪字型继续模拟，发现仅需要2次询问即可。而且我们加长某条链，询问次数不变，说明变化是在度>=3的点上发生的。但是当扩展到更复杂的情况时，会遇到一些问题。我们希望其存在某些规律，可以用树dfs搞定，但是如果以节点为单位看的话，显然是错误的。于是我们假设，使用dfs遍历时，根节点默认选择。在根节点默认选择这个条件下模拟，规律相对明显。首先可知，如果选择所有叶节点，一定是可行的，我们可以给叶节点染上白色。若白点和旁边的点可以形成链结构，则白色扩张——在思维上可以认为没有链的中间点。现在对于任意一个非白色的点来说，如果其有n的度，其中n-1条边都是被询问激活的，另一条边指向的点是白点，则可以视作另一条变也被激活。这里规律细节比较多，仔细思考一下ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 inline void solve() { cin>>n; vector<vector<int>> g(n+5); vector<int> vis(n+5); m = n-1; while (m--) { int u, v; cin>>u>>v; g[u].push_back(v); g[v].push_back(u); } if (n==1) { cout<<0<<endl; return; } queue<int> q; for (int i=1; i<=n; i++) if (g[i].size()==1) q.push(i), vis[i]=1; // vis[x]=1表示白点 while (q.size()) // 白点扩张 { int u=q.front(); q.pop(); for (int v:g[u]) { if (g[v].size()==2 && vis[v]==0) { q.push(v); vis[v]=1; } } } int ans=0; for (int i=1; i<=n; i++) { if (vis[i]) continue; // 找到非白点 int cnt=0; // 非白点之间可以视作默认激活 for (int v:g[i]) cnt += vis[v]; ans += max(0ll, cnt-1); } ans = max(1ll, ans); // 因为0的情况已经被特判出去了 cout<<ans<<endl; return; }title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。

Codeforces Round 796 (Div. 2) The Enchanted Forest算法本质思维题目大意一维坐标上1~n上有n个金币产生器，0秒时每个金币产生器旁的金币是a[]表示，其每秒可以产生1金币。玩家0秒时可以移动至任意一点，一秒内会顺序进行以下操作：玩家移动至相邻格子或者不变玩家收集在这个格子上的所有金币金币产生器都产出1金币在第k秒时，输出最大化的金币收集数。（相当于进行以上k次操作）思路推演朴素的想可以发现，当k<n时，玩家总是不喜欢走回头路的。然后开始证明。玩家的收益可以大体分成两个部分：初始金币 + 增长金币如果玩家回头，则两部分收益都会下降，得证。不回头，则增长金币收益不变，所以只要找长度k的最大子段和。但是k>=n的情况可能有所不同。初始金币一定是会完全收集的，那如何才能得到最多的增长金币呢。也许可以反过来想一想，既然时间固定，增长金币的总数是一定的，我们只需要让增长金币最后剩余在地图上最少即可——k操作的最后n次操作完整走一遍地图即可。（之前的时间可以在原地发呆）ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 inline void solve() { cin>>n>>k; vector<int> a(n+5); read(a, 1, n); int res, ans; if (k<n) { res = accumulate(a.begin()+1, a.begin()+1+k, 0ll); ans = res; for (int i=k+1; i<=n; i++) { res += -a[i-k] + a[i]; ans = max(ans, res); } ans += (k-1)*k/2; // 增长金币部分 } else { ans = accumulate(a.begin()+1, a.begin()+1+n, 0ll); int more = (n-1)*n/2; more += (k-n)*n; ans += more; } cout<<ans<<endl; return; }Sanae and Giant Robot算法本质思维 !题目大意给定两个长度n数组a[] b[]和m个区间，玩家希望让a[]变得同b[]一致，可以进行任意次一下操作：选择某个区间l r，保证$\sum_{i=l}^{r}a_i = \sum_{i=l}^{r}b_i$，然后使得a[l~r] := b[l~r]思路推演朴素地去想暂时没结果，缺少进入的思路。然后就想不出来了显然，如果a[] b[]的元素之和不相等，则肯定不可行。当我们使用操作时，似乎将一个数组分割成了两份，我们是否需要维护两份数组的也遵从上面的规律呢。我们回溯操作观察，这个规律会更明显。至此我们修改操作的规则：选择某个区间l r，保证$pa[l-1]=pb[l-1] \quad and \quad pa[r]=pb[r] $，然后使得a[l~r] := b[l~r]新的操作规则，才能称之为有效操作，其他的操作可以视作无效甚至于破坏相等抽象题意：可以视作这里有下标0开始长度n+1的01数组c[]和m个区间。若区间l r满足c[l] = c[r] = 1则可以使得c[l~r] := 1。最后希望使得c[0 ~ n]=1分析一下，我们希望能做一个类似触发器的东西，当c[l] = c[r] = 1时可以触发至某个区间。当然使用二维信息作key值显然复杂度不允许，所以就以下标做key值，触发时判断一下另外一个条件即可。另外当我们进行c[l~r] := 1操作时，那些从0值变成1值，会进行一次触发。这可以使用并查集里的find来优化——因为所有下标只触发一次。ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 // 借用并查集find的优化结构 int go[maxn]; int find(int x) // 找到右边（含自己）第一个未被遍历的 { if (go[x]==0) return x; return go[x] = find(go[x]); } inline void solve() { cin>>n>>m; vector<int> a(n+5), b(n+5), c(n+5); read(a, 1, n); read(b, 1, n); vector<int> tol(m+5), tor(m+5); // 第i个区间的信息：id --> 下标 vector<vector<int>> booml(n+5), boomr(n+5); // 下标 --> id for (int i=1; i<=m; i++) { int l, r; cin>>l>>r; l--; tol[i] = l; tor[i] = r; booml[l].push_back(i); boomr[r].push_back(i); } queue<int> q; auto f = [&](int p) { // 触发器 c[p] = 1; go[p] = p+1; for (int id:booml[p]) if (c[ tor[id] ]) // 成功触发 q.push(id); for (int id:boomr[p]) if (c[ tol[id] ]) q.push(id); }; int pa=0, pb=0; for (int i=0; i<=n+1; i++) go[i]=0; // 这里注意细节使得go[n+1]=0 for (int i=0; i<=n; i++) { pa += a[i]; pb += b[i]; if (pa==pb) f(i); // 触发 } while (q.size()) { int id=q.front(); q.pop(); int l=tol[id], r=tor[id]; for (int p=find(l); p<=r; p=find(p)) // 触发 f(p); } flag = 1; for (int i=0; i<=n; i++) flag &= c[i]; cout<<(flag ? "YES" : "NO")<<endl; return; }title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。

Codeforces Round 794 (Div. 2) Linguistics算法本质思维题目大意玩家手中有4种不同的字符串特定个数：a b ab ba题目会给出s，输出玩家能否恰好使用完手中的字符串，将其组合成s。思路推演稍加模拟可以发现，因为不存在某个字符串有连续的a或b，所以可以将s分开成若干组，每组不得有连续a或b。这样情况就缩小至4种了：偶数长度（分别考虑a打头和b打头）以abababab为例，其中一种情况自然是使用4个ab搞定。思考如果使用了ba的情况，则可以视作a + b + 3个通用，这里的通用指的是ab或ba，没有限制奇数长度（分别考虑a打头和b打头）以abababa为例，肯定需要一个离散的a，剩下部分用3个通用即可还有一点需要思考的是，偶数长度的组，到底应该使用哪种情况。这里贪心的想，离散的a b优先级是最高的，我们希望ababab最好使用3个ab，当然这里有多个组，但是每个组选择另一种情况都是消耗相同的一对离散a b。所以我们将这些组按长度排序，尽可能满足长度小的组（这样尽可能减少a b的使用）ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 inline void solve() { map<string, int> mp, cod; vector<int> ab, ba; cin>>mp["a"]>>mp["b"]>>mp["ab"]>>mp["ba"]; // 记录玩家手中的字符串 string s; cin>>s; auto f = [&](int l, int r) { int len=r-l+1; if (len%2) { cod["tong"] += len/2; // 使用ab ba a+b if (s[l]=='A') cod["a"]++; // 使用离散a else cod["b"]++; // 使用离散b } else { if (s[l]=='A') ab.push_back(len/2); // 需要用len/2个ab 或者 a+b+(len/2-1)个通用 else ba.push_back(len/2); // 同理 } }; for (int l=0, r; l<s.length(); l=r+1) // 分组 { r=l; while (r<s.length()-1 && s[r]!=s[r+1]) r++; f(l, r); } flag = 1; sort(ab.begin(), ab.end()); reverse(ab.begin(), ab.end()); sort(ba.begin(), ba.end()); reverse(ba.begin(), ba.end()); // 长度小的组放后边 // 先考虑离散的 a b mp["a"] -= cod["a"]; mp["b"] -= cod["b"]; if (mp["a"]<0 || mp["b"]<0 || mp["a"]!=mp["b"]) flag = 0; int cnt = mp["a"]; // a+b数目 while (ab.size() && mp["ab"]>=ab.back()) // 优先使用原生ab { mp["ab"] -= ab.back(); ab.pop_back(); } while (ba.size() && mp["ba"]>=ba.back()) // 优先使用原生ba { mp["ba"] -= ba.back(); ba.pop_back(); } if (cnt < ab.size() + ba.size()) // 有ab.size() + ba.size()实在需要离散对 a+b flag = 0; cnt += mp["ab"] + mp["ba"]; cod["tong"] += accumulate(ab.begin(), ab.end(), 0ll) + accumulate(ba.begin(), ba.end(), 0ll); if (cnt != cod["tong"]) flag = 0; cout<<(flag ? "YES" : "NO")<<endl; return; }Bring Balance算法本质思维题目大意给定长度2n的括号序列，其中有n个左括号、n个右括号。玩家希望最后的括号序列合法，可以执行以下操作：选择区间l r，执行s.reverse(l, r)输出最小化的操作次数。思路推演括号序列的合法，这类题目使用前缀和数组来看待是最好的。玩家的目的是使得前缀和数组都>=0。ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。

Codeforces Round 793 (Div. 2) Circular Spanning Tree算法本质思维题目大意n个点顺序围成了一个环，给定长度n的01串s，现在玩家需要连接n-1条边，需要满足：形成连通所有点的树结构所有的边的交点只能在节点上s[i]是01分别表示第i个点的度是偶数、奇数输出连接方案思路推演核心在于奇偶ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 inline void solve() { string s; cin>>n>>s; int cnt = count(s.begin(), s.end(), '1'); if (cnt==0 || cnt%2) { cout<<"NO"<<endl; return; } vector<pair<int, int>> ans; int p=s.find_first_of('1'); // 找到一个字符作为起点 vector<int> cod; for (int l=p, r; l<p+n; l=r) { r = l+1; while (s[r%n]=='0') { ans.push_back({(r-1)%n, r%n}); r++; } cod.push_back((r-1)%n); } for (int i=1; i<cod.size(); i++) ans.push_back({cod[0], cod[i]}); cout<<"YES"<<endl; for (auto [u,v]:ans) cout<<u+1<<' '<<v+1<<endl; return; }Unordered Swaps算法本质思维、图论基础题目大意给定长度n排列p[]，Alice执行了m次交换操作使得p[]升序（保证m是最小操作次数），每次操作记录交换元素下标。现在将这m次操作乱序后给出，玩家需要恢复其顺序使其合法。（恢复的顺序可以使得p[]升序）思路推演对于排列交换、形式与[1, 2, ... , n]有关的，都可以将其分组。分组的方式：对于任意p来说。a[p]、a[ a[p] ]在同一集合，且可以视作a[p] --> a[ a[p] ]每组会必然形成一个环利用分组进行观察，使其升序的本质是每个元素单独一组。为了尽可能少的交换，我们需要保证每次交换操作都是选择两个同组的元素操作，这样可以将一个组打破成两个组。难点在于，操作是固定的，我们是分配其顺序，需要保证所有的操作都是打破组，或者说所有操作的元素都是同组的。那么，对于一次x y的交换来说，其对于环来说的意义是什么。在组里，元素值和下标随时都在转换，它既是元素值、也是另一元素的下标！模拟：a[]: 2 4 1 5 3 这个数组仅会形成一个环：2 --> 4 --> 5 --> 3 --> 1 如果交换(2, 5)则会变成：2 3 1 5 4 即：2 --> 3 --> 1 和 5 --> 4多次使用可以发现，选择(x, y)，则会以x y为起点分裂出两个环。如果有两个(x, y1)和(x, y2)，则显然我们需要先使用举例x较远的y，这样至少对于有x的操作来说，其不会犯错。进一步思考可以发现，对于任意两个交换操作，若其在同一环上出现，则其仅有包含、相离这两种情况，不会出现存在部分交集的情况。否则其就不符合使用最小次数使得p[]升序。于是我们就可以随意组合其他的操作顺序。ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 inline void solve() { cin>>n>>m; vector<int> a(n+5); vector<vector<pair<int, int>>> g(n+5); for (int i=1; i<=n; i++) cin>>a[i]; for (int i=1; i<=m; i++) { int u, v; cin>>u>>v; g[u].push_back({v, i}); g[v].push_back({u, i}); } vector<int> vis(n+5), pos(n+5); // vis[x]记录元素值x是否使用，pos[x]记录元素值x在环的相对位置 vector<vector<int>> g2(m+5); // g2以id1为key值记录边的topo图 vector<int> ru(m+5), ans; // g2图的入度 for (int i=1; i<=n; i++) { int x = a[i]; if (vis[x]) continue; vector<int> v; // v[]用于记录当前环的元素值 set<int> cod; // cod用于维护当前轮次g2图的入度0的id int siz=0; while (vis[x]==0) { vis[x] = 1; pos[x] = siz++; // 每个环的下标 v.push_back(x); x = a[x]; } for (int u:v) // 依次处理环的每个值 { sort(g[u].begin(), g[u].end(), [&](const pair<int,int> &a, const pair<int,int> &b) { // 距离u相对远的放在前 int v1=a.first, v2=b.first; return (pos[v1] - pos[u] + siz) % siz < (pos[v2] - pos[u] + siz) % siz; }); for (int j=1; j<g[u].size(); j++) { int id1=g[u][j-1].second, id2=g[u][j].second; g2[ id1 ].push_back(id2); ru[id2]++; } if (g[u].size()) // 记录可能的入度0的id cod.insert(g[u][0].second); } queue<int> q; for (int id:cod) if (ru[id]==0) q.push(id); while (q.size()) { int u=q.front(); q.pop(); ans.push_back(u); for (int v:g2[u]) if (--ru[v]==0) q.push(v); } } for (int x:ans) cout<<x<<" "; cout<<endl; return; }title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。

Educational Codeforces Round 155 (Rated for Div. 2) Chips on the Board算法本质思维题目大意给定2个长度n的数组a[] b[]，现在有一个空白的n*n的棋盘，玩家需要放置若干个棋子满足：每个棋格的所处的行或列至少存在一个棋子每个棋子放置有成本：放置在(i, j)位置，需要a[i]+b[j]元输出玩家的最小化成本。思路推演一种朴素的想法就是：以行为单位，每行必须存在一个棋子以列为单位，每列必须存在一个棋子证： 若存在某种方式，第i行不存在棋子、第j列不存在棋子 则(i,j)格子不合法所以，既然每行都需要一个棋子，则a[]数组的贡献就是其元素和，b[]的贡献可以调整最小元素*n。Make it Alternating算法本质思维题目大意给定01串s，希望s变成交错的（不出现连续1或连续0），玩家可以操作：删除某个字符在最少删除次数下，玩家删除的方案数。（注意，删除不同下标的字符视作不同操作，不同删除顺序视作不同操作）思路推演最少删除次数很容易求得。例如100011110删除的次数显然是2+3。核心在于操作数的计算，例如3个0，实际上只能删除2个元素。计算方式：3个0中，C(3, 1)计算留下来的0的情况，另外2个操作放入操作池，4个1也同理。操作池有5个操作，全排列即可。ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 inline void solve() { string s; cin>>s; int ans=1, kind=0; for (int l=0, r=0; l<s.length(); l=r) { while (r<s.length() && s[l]==s[r]) r++; kind++; ans = ans * (r-l) % mod; } for (int i=1; i<=s.length()-kind; i++) ans = ans*i%mod; cout<<s.length()-kind<<" "<<ans<<endl; return; }Sum of XOR Functions算法本质思维题目大意给定长度n数组a[]，定义：$f(l,r) = a[l] ⊕ a[l+1] ⊕ ... ⊕ a[r]$输出$\sum_{l=1}^n\sum_{r=l}^nf(l,r) * (r-l+1)$思路推演首先想到的就是拆位，拆位后效果会好很多。拆位后题目就变成一个很简单的了，至少思路上没有什么障碍了。ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 inline void solve() { cin>>n; vector<int> a(n+5); for (int i=1; i<=n; i++) cin>>a[i]; int ans=0; for (int val=1; val<=1e9; val*=2) { // num[0]表示奇数目前能作为左端点的个数，w[0]表示能作所有奇数左端点到目前下标的和 int num[2]={0, 0}, w[2]={0,0}; int res=0, x=0; // x表示当前是奇数点还是偶数点(注意奇偶切换的状态) for (int i=1; i<=n; i++) { num[x]++; w[0] += num[0]; w[1] += num[1]; if (a[i] & val) // 奇偶切换 x ^= 1; res += w[x^1]; // 当前点作为右端点，可以收获w[x^1]的倍率 num[x] %= mod; w[0] %= mod; w[1] %= mod; res %= mod; } ans += res*val; ans %= mod; } cout<<ans<<endl; return; }Interactive Game with Coloring算法本质思维题目大意给定n大小的树，其中1是根节点。玩家需要对树的边染色，然后保证在以下游戏必胜：初始时玩家会被传送至某个未知的非1节点如果玩家目前处于非1节点，可以知道附近任意颜色的边的数目，（玩家看来）相同颜色的边没有区别，然后选择一条边走玩家必须保证每次行动都能缩减与节点1的距离，否则计为失败，当抵达1时成功在保证必胜的前提下，减少使用的颜色种类。玩家需要输出染色方案，同时还需要完成游戏（交互题）。思路推演稍加模拟就发现了一个特别简单的思路：设节点1深度为0，则对任意深度为x的通向父节点的边，模3同余的点染相同颜色。这样的话，每个节点的边至多存在2种颜色——一共三种可能，然后根据情况选择，可以保证自己深度一直减小。那接下来还需要考虑仅用1种颜色和2种颜色的情况了。通过样例可以发现，如果节点最大深度为1，那就可以使用1种颜色即可，那增加深度是否还可以保证仅用一种颜色呢？显然不行，深度>1时一定存在某点有多条边，同种颜色边无区别，玩家无法选择唯一正确的边行动。那接下来就是2种颜色的情况了。当最大深度>2时，能否存在情况仅用2种颜色——显然是可行的。思考，可行动的本质是什么，首先正确的边的颜色只能为1。所以在2种颜色的情况下，边的颜色交替染色，还有一个问题是：某个节点的2种颜色的数目都是1——这需要事先规定。我们称仅有2条边相连的非1节点为斑点，节点1以下的子树是一个整体，这个整体中的斑点如果深度的奇偶不一致，则不可行，反之可行。ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 int fu[maxn], c[maxn]; vector<int> g[maxn]; vector<int> ck(int u, int dep) // 检查斑点的奇偶个数 { vector<int> res(2); if (g[u].size()==1) res[dep%2]++; for (int v:g[u]) { vector<int> t=ck(v, dep+1); res[0] += t[0]; res[1] += t[1]; } return res; } void tu(int u, int col, int top) // 染色函数 { if (col>top) col-=top; c[u] = col; for (int v:g[u]) tu(v, col+1, top); } inline void solve() { cin>>n; k = 1; for (int v=2; v<=n; v++) { int u=in(); g[u].push_back(v); fu[v] = u; if (fu[v]!=1) k=2; } if (k==1) // 检查是否可以用1种颜色搞定 { cout<<k<<endl; for (int i=2; i<=n; i++) cout<<1<<" \n"[i==n]; cout.flush(); while (1) { int op=in(); if (op==1) break; int t=in(); cout<<1<<endl; cout.flush(); } return; } for (int u:g[1]) // 检查k=2的情况 { vector<int> x=ck(u, 1); if (x[0]>0 && x[1]>0) k = 3; } if (k==2) { cout<<k<<endl; for (int u:g[1]) // 默认如果1、2颜色都是数目1，选择颜色1 { vector<int> x=ck(u, 1); if (x[0]>0) tu(u, 2, k); else tu(u, 1, k); } for (int i=2; i<=n; i++) cout<<c[i]<<" \n"[i==n]; cout.flush(); while (1) { int op=in(); if (op==1) break; vector<int> num(k+1); cin>>num[1]>>num[2]; cout<<(num[1]==1 ? 1 : 2)<<endl; // 默认如果1、2颜色都是数目1，选择颜色1 cout.flush(); } return; } // k=3的情况 cout<<k<<endl; tu(1, 0, k); for (int i=2; i<=n; i++) cout<<c[i]<<" \n"[i==n]; cout.flush(); while (1) { int op=in(); if (op==1) break; vector<int> num(k+1); cin>>num[1]>>num[2]>>num[3]; int res; if (num[1] + num[2] + num[3] == 1) { if (num[1]==1) res=1; else if (num[2]==1) res=2; else res=3; } else if (num[1]==0) res=2; else if (num[2]==0) res=3; else res=1; cout<<res<<endl; cout.flush(); } return; }title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。 title算法本质题目大意思路推演ac核心代码头文件、宏定义、快读模板、常见变量、常见变量等略。