ZOJ Monthly, June 2014 解题报告

最新推荐文章于 2018-08-15 21:36:47 发布
最新推荐文章于 2018-08-15 21:36:47 发布
阅读量1.3k 收藏
点赞数 1
分类专栏： ACM 比赛解题报告 文章标签： dp 并查集 网络流 强连通分量
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/randygx/article/details/27978859
版权

A.Another Recurrence Sequence

B.Gears

题目大意：有n个齿轮，一开始各自为一组，之后进行m次操作，包括以下4种类型：
1.合并两组齿轮，合并的两个应该反向旋转
2.把某个齿轮从所在组删除，自为一组，但不影响同组其它齿轮的状态与关系
3.询问两个齿轮是同向、反向或无关系(即不在同一组)
4.询问某个齿轮所在组的齿轮总数

分析：典型的并查集操作，但是注意两点：
1.由于操作3要询问两个齿轮的相对状态，因此对并查集中每个元素应当保存它的状态信息。状态是相对的，只需要保存每个元素相对于父元素的状态，在查询所属集合时顺便更新状态信息。如用depth[i]表示齿轮i相对于父齿轮的深度，那么两个齿轮属于同一组且深度奇偶性相同时同向旋转。更新depth数组也行简单，i对j的深度 = i对k的深度 + k对j的深度。
2.操作2涉及删除某个元素。另外开一个数组id，用id[i]表示元素i实际所在的位置，当删除元素i时，令id[i] = new id，同时fa[id[i]] = id[i]，即id[i]自为一组。这样一来，之后涉及到元素i的操作都用id[i]代替，而原来的i元素依然存在，只不过它只起到占位的作用，以维持原集合的相对关系。相当于id[i]表示元素i的指针。 

#include 
    
    
     
     
#include 
     
     
      
      
#include 
      
      
       
       
#include 
       
       
        
        
#include 
        
        
          #include 
          #include 
          
            #include 
           
             #include 
            
              #include 
             
               #include 
              
                #include 
               
                 #include 
                
                  #include 
                 
                   #include 
                  
                    #include 
                   
                     #include 
                    
                      #define mp make_pair #define X first #define Y second #define MEMSET(a, b) memset(a, b, sizeof(a)) using namespace std; typedef unsigned int ui; typedef long long ll; typedef unsigned long long ull; typedef pair 
                     
                       pii; typedef vector 
                      
                        vi; typedef vi::iterator vi_it; typedef map 
                       
                         mii; typedef priority_queue 
                        
                          pqi; typedef priority_queue 
                         
                           , greater 
                          
                            > rpqi; typedef priority_queue 
                           
                             pqp; typedef priority_queue 
                            
                              , greater 
                             
                               > rpqp; const int MAX_N = 200000 + 2; int fa[MAX_N * 3], num[MAX_N * 3], depth[MAX_N * 3]; int id[MAX_N * 3]; int cnt; int find_fa(int x) { if (fa[x] == x) { return x; } int tmp = fa[x]; fa[x] = find_fa(fa[x]); depth[x] += depth[tmp]; return fa[x]; } void union_set(int x, int y) { int headx = find_fa(x); int heady = find_fa(y); if (headx != heady) { fa[heady] = headx; depth[heady] = depth[y] + 1 + depth[x]; num[headx] += num[heady]; } } void del(int x) { --num[find_fa(id[x])]; id[x] = ++cnt; x = id[x]; fa[x] = x; num[x] = 1; depth[x] = 0; } int main(int argc, char *argv[]) { // freopen("D:\\in.txt", "r", stdin); int n, m, i; while (scanf("%d%d", &n, &m) == 2) { MEMSET(depth, 0); cnt = n; for (i = 1; i <= n; ++i) { id[i] = i; fa[i] = i; num[i] = 1; } while (m--) { char ch; scanf("\n%c", &ch); if (ch == 'L') { int a, b; scanf("%d%d", &a, &b); a = id[a], b = id[b]; union_set(a, b); } else if (ch == 'D') { int a; scanf("%d%d", &a); del(a); } else if (ch == 'Q') { int a, b; scanf("%d%d", &a, &b); a = id[a], b = id[b]; if (find_fa(a) != find_fa(b)) { puts("Unknown"); } else if ((depth[a] & 1) == (depth[b] & 1)) { puts("Same"); } else { puts("Different"); } } else { int a; scanf("%d", &a); a = id[a]; printf("%d\n", num[find_fa(a)]); } } } return 0; }

C.Consecutive Blocks

题目大意：给定一个整数序列，要求删除最多k个数后，新序列中连续相等的子序列长度最大，输出该最大长度。

分析：除了F题搞笑外这个就是最简单的题了。记录每个数出现的位置(由于数字可能很大，先把数字映射到1..k)，然后计算以每个位置结束时的最大长度即可。

D.An Easy Game

题目大意：给定两个0-1序列s1, s2，操作t次，每次改变m个位置，求把s1改变为s2的方法总数。

分析：明显的DP，注意s1和s2哪些位置相同并不重要，重要的是有几个位置不同。改变的时候也一样，改变哪些位置并不重要，重要的是改变之后有几个位置不同。所以用dp[i][j]表示i次操作之后有j个位置不同的方法数，答案就是dp[t][0]。对于dp[i - 1][j]，经过一次操作之后假设把k个位置从不同变为相同，剩下m - k个位置从相同变为不同，那么
dp[i][j + m - k - k] += dp[i - 1][j] * C(j, k) * C(n - j, m - k)
其中C(j, k)表示组合数，即从j个不同的位置选出k个改变。循环k即可。 

#include 
    
    
     
     
#include 
     
     
      
      
#include 
      
      
       
       
#include 
       
       
        
        
#include 
        
        
          #include 
          #include 
          
            #include 
           
             #include 
            
              #include 
             
               #include 
              
                #include 
               
                 #include 
                
                  #include 
                 
                   #include 
                  
                    #include 
                   
                     #define mp make_pair #define X first #define Y second #define MEMSET(a, b) memset(a, b, sizeof(a)) using namespace std; typedef unsigned int ui; typedef long long ll; typedef unsigned long long ull; typedef pair 
                    
                      pii; typedef vector 
                     
                       vi; typedef vi::iterator vi_it; typedef map 
                      
                        mii; typedef priority_queue 
                       
                         pqi; typedef priority_queue 
                        
                          , greater 
                         
                           > rpqi; typedef priority_queue 
                          
                            pqp; typedef priority_queue 
                           
                             , greater 
                            
                              > rpqp; const int MAX_N = 100 + 2; const int MOD = 1000000009; char str[2][MAX_N]; ll dp[MAX_N][MAX_N]; int C[MAX_N][MAX_N]; void compute_C() { C[0][0] = 1; for (int i = 1; i <= 100; ++i) { C[i][0] = 1; for (int j = 1; j <= i; ++j) { C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD; } } } int main(int argc, char *argv[]) { // freopen("D:\\in.txt", "r", stdin); compute_C(); int n, t, m, i, j, k; while (scanf("%d%d%d\n", &n, &t, &m) == 3) { gets(str[0]); gets(str[1]); int cnt = 0; for (i = 0; i < n; ++i) { cnt += str[0][i] != str[1][i]; } MEMSET(dp, 0); dp[0][cnt] = 1; for (i = 1; i <= t; ++i) { for (j = 0; j <= n; ++j) { for (k = max(0, m - n + j); k <= j && k <= m; ++k) { dp[i][j + m - k - k] = (dp[i][j + m - k - k] + dp[i - 1][j] * C[j][k] % MOD * C[n - j][m - k] % MOD) % MOD; } } } printf("%d\n", dp[t][0]); } return 0; }


题目大意：给定一个无向图，要求删除一些边使点p和点q不连通，首先是使花费最少，若有多组解则使删除的边最少。

分析：典型的最小割，最大流即可。只需要把每边的花费c改为c = c * (|E| + 1) + 1即可使删除的边最少，其中|E|为边数。为方便把|E|换为一个较大的数也可以。 

#include 
     
     
      
      
#include 
      
      
       
       
#include 
       
       
        
        
#include 
        
        
         
         
#include 
         
         
           #include 
           #include 
           
             #include 
            
              #include 
             
               #include 
              
                #include 
               
                 #include 
                
                  #include 
                 
                   #include 
                  
                    #include 
                   
                     #include 
                    
                      #define mp make_pair #define X first #define Y second #define MEMSET(a, b) memset(a, b, sizeof(a)) using namespace std; typedef unsigned int ui; typedef long long ll; typedef unsigned long long ull; typedef pair 
                     
                       pii; typedef vector 
                      
                        vi; typedef vi::iterator vi_it; typedef map 
                       
                         mii; typedef priority_queue 
                        
                          pqi; typedef priority_queue 
                         
                           , greater 
                          
                            > rpqi; typedef priority_queue 
                           
                             pqp; typedef priority_queue 
                            
                              , greater 
                             
                               > rpqp; const int MAX_N = 50 + 2; const int INF = (int)1.0e9; int g[MAX_N][MAX_N]; int dis[MAX_N]; int q[MAX_N]; bool bfs(int source, int sink, int n) { MEMSET(dis, -1); dis[source] = 0; int head = 0, tail = 0; q[tail++] = source; while (head != tail) { int k = q[head++]; for (int i = 1; i <= n; ++i) { if (g[k][i] > 0 && dis[i] < 0) { dis[i] = dis[k] + 1; q[tail++] = i; } } } return dis[sink] > 0; } int dfs(int n, int sink, int x, int mx) { if (x == sink) { return mx; } int a; for (int i = 1; i <= n; ++i) { if (g[x][i] > 0 && dis[i] == dis[x] + 1 && (a = dfs(n, sink, i, min(mx, g[x][i])))) { g[x][i] -= a; g[i][x] += a; return a; } } return 0; } int dinic(int n, int source, int sink) { int ret = 0; while (bfs(source, sink, n)) { ret += dfs(n, sink, source, INF); } return ret; } int main(int argc, char *argv[]) { // freopen("D:\\in.txt", "r", stdin); int T; cin >> T; while (T--) { int n, m, p, q, sum = 0; scanf("%d%d%d%d", &n, &m, &p, &q); MEMSET(g, 0); while (m--) { int a, b, c; scanf("%d%d%d", &a, &b, &c); sum += c; g[a][b] += c * 1111 + 1; g[b][a] += c * 1111 + 1; } int ans = dinic(n, p, q); if (!ans) { puts("Inf"); } else { printf("%.2lf\n", (double)(sum - ans / 1111) / (ans % 1111)); } } return 0; }


分析：搞笑题，就不解释了。



题目大意：给定一个有向图，要求把点分为k个集合，使得每个集合中的任意两点a, b满足a, b互相不可到达。

分析：求出强连通分量后缩点，得到有向无环图，dfs该图求出各点深度(深度加权，权值为强连通分量大小)，深度最大值即答案，因为这一条路径上任意两点都可从深度小的一点到达深度大的一点，所以必定属于不同集合；又可以把其它路径(长度为len)上的各点依次归到集合1..len。 

#include 
     
     
      
      
#include 
      
      
       
       
#include 
       
       
        
        
#include 
        
        
         
         
#include 
         
         
           #include 
           #include 
           
             #include 
            
              #include 
             
               #include 
              
                #include 
               
                 #include 
                
                  #include 
                 
                   #include 
                  
                    #include 
                   
                     #include 
                    
                      #define mp make_pair #define X first #define Y second #define MEMSET(a, b) memset(a, b, sizeof(a)) using namespace std; typedef unsigned int ui; typedef long long ll; typedef unsigned long long ull; typedef pair 
                     
                       pii; typedef vector 
                      
                        vi; typedef vi::iterator vi_it; typedef map 
                       
                         mii; typedef priority_queue 
                        
                          pqi; typedef priority_queue 
                         
                           , greater 
                          
                            > rpqi; typedef priority_queue 
                           
                             pqp; typedef priority_queue 
                            
                              , greater 
                             
                               > rpqp; const int MAX_N = 100000 + 2; vi link[MAX_N], relink[MAX_N]; int dfn[MAX_N], low[MAX_N], belong[MAX_N], num[MAX_N]; int stk[MAX_N]; int top, idx, cnt; int len[MAX_N]; void dfs(int u) { dfn[u] = low[u] = ++idx; stk[top++] = u; int v; for (int i = 0; i < link[u].size(); ++i) { if (!dfn[v = link[u][i]]) { dfs(v); low[u] = min(low[u], low[v]); } else if (!belong[v]) { low[u] = min(low[u], dfn[v]); } } if (dfn[u] == low[u]) { num[belong[u] = ++cnt] = 1; while (stk[--top] != u) { ++num[belong[stk[top]] = cnt]; } } } void tarjan(int n) { MEMSET(belong, 0); MEMSET(dfn, 0); cnt = idx = top = 0; for (int i = 1; i <= n; ++i) { if (!dfn[i]) { dfs(i); } } } void rebuild_graph(int n) { int i, j; for (i = 1; i <= cnt; ++i) { relink[i].clear(); } for (i = 1; i <= n; ++i) { for (j = 0; j < link[i].size(); ++j) { if (belong[i] != belong[link[i][j]]) { relink[belong[i]].push_back(belong[link[i][j]]); } } } } int _dfs(int u) { if (len[u]) { return len[u]; } for (int i = 0; i < relink[u].size(); ++i) { len[u] = max(len[u], _dfs(relink[u][i])); } return len[u] += num[u]; } int main(int argc, char *argv[]) { // freopen("D:\\in.txt", "r", stdin); int n, m, i; while (scanf("%d%d", &n, &m) == 2) { for (i = 1; i <= n; ++i) { link[i].clear(); } while (m--) { int s, t; scanf("%d%d", &s, &t); link[s].push_back(t); } tarjan(n); rebuild_graph(n); MEMSET(len, 0); int ans = 0; for (i = 1; i <= cnt; ++i) { ans = max(ans, _dfs(i)); } printf("%d\n", ans); } return 0; }



randygx
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ZOJ Monthly, June 2014 F - First Digit
acm_1361677193的专栏
08-03 746
F - First Digit Time Limit:2000MS     Memory Limit:65536KB     64bit IO Format:%lld & %llu Submit Status Description Benford's Law, also called the First-Digit Law, refers to the frequ
ZOJ Monthly, June 2014部分题解
Tongqi
07-18 733
感觉挺不错的一套题，写下部分题目的题解 ZOJ 3789： Gears 题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3789 题意：有N个齿轮，齿轮间只有旋转方向相反才能连接，给出四个操作 L X Y ：将齿轮X, Y连接，如果它们已经有已属集合，那集合也要合并 D X：拆掉齿轮X，且X所...
ZOJ 2014 Piggy-Bank(完全背包)
蚂蚁大战大象
04-21 556
这题是求的最小的 转移方程:f[i][v]=min{f[i-1][v-k*c[i]]+k*w[i]|0 #include #include #include using namespace std; const int maxn=10010; int dp[maxn],w[510],v[510],E,F,N; int main(){ int t; scanf("%d",&t); w
【ZOJ 2014】【Piggy-Bank】
哇哈哈哈的博客
08-15 154
题目： Before ACM can do anything, a budget must be prepared and the necessary financial support obtained. The main income for this action comes from Irreversibly Bound Money (IBM). The idea behind is s...
ZOJ3613-Wormhole Transport
wang_128的博客
11-13 422
Wormhole Transport Time Limit: 3 Seconds      Memory Limit: 65536 KB Wormhole is a kind of two-way tunnel between two planets which can make it possible to transport large amounts of resources
ZOJ月赛 题解 (ZOJ Monthly, August 2014)
01-22
通过深入研究20141007(ZOJ Monthly, August 2014)这个压缩包中的解题报告和代码，我们可以学习到上述及其他更多编程和算法技巧，同时了解高手们是如何思考和解决问题的，这对于提升编程思维和参加类似竞赛将大有裨益...
ZOJ解题报告ZOJ解题报告
08-02
ZOJ解题报告ZOJ解题报告ZOJ解题报告ZOJ解题报告
zoj 解题报告 C语言
11-21
【标题】"Zoj解题报告C语言"涵盖了在ZOJ（在线判题系统）上使用C语言解决算法竞赛问题的详细策略和方法。ZOJ是众多计算机编程竞赛平台之一，它提供了大量的算法题目供参赛者挑战，以提高编程技能和算法理解能力，...
acm zoj1181 解题报告，用STL库
10-12
acm zoj1181 解题报告，用STL库
ACM训练必备POJ ZOJ题目分类及解题思路
04-19
学习ACM程序设计的朋友一定要看，这是训练必备的POJ ZOJ题目分类及解题思路
zoj 2014 Let the Balloon Rise（水~）
小媛在努力~
07-22 1000
<br />找出出现颜色次数最多的颜色~<br /> <br />我用结构体了，数组开得有点小，WA了一次。。悲剧。。。<br /> <br />因为WA搜别人代码时，搜到某柯的了，用的map？？map是啥。。图么。。不会哎。。<br /> <br />他大一的现在都已经好强了。。。哎。。好惭愧呀。。<br /> <br />#include <stdio.h> #include <stdlib.h> #include <string.h> struct ballon { char col
线段树求LIS并统计最长子序列个数
randygx的专栏
05-04 2192
求最长单增子序列(LIS)长度并统计取得最大长度的子序列数。扩展：把LIS换成最长先增后减子序列
2014嘉杰信息杯ACM/ICPC湖南程序设计邀请赛暨第六届湘潭市程序设计竞赛 解题报告
randygx的专栏
06-08 1654
A simple problem w
TOJ 3883: Roadblock -- 单源最短路
randygx的专栏
05-02 1070
3883: Roadblock Time Limit(Common/Java):1000MS/3000MS     Memory Limit:65536KByte Total Submit: 17            Accepted:7 Description Every morning, FJ wakes up and walks across the farm fro
Codeforces Round #244 (Div. 2)
randygx的专栏
05-03 1015
Codeforces Round #244 (Div. 2) 解题报告
TOJ 1631 Naptime -- 环形DP
randygx的专栏
05-29 954
题目链接：http://acm.tzc.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1631
TOJ 1551 Power Hungry Cows -- 搜索
randygx的专栏
05-27 854
题目链接：http://acm.tzc.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1551
zoj1959四分数解题分析
最新发布
06-12
ZOJ1959是一道经典的动态规划题目，可以使用常规的动态规划算法来解决。但是，它也可以使用四分数解法来解决，这种方法更加高效，可以通过本题。 四分数解法的基本思路是：将字符串分成四份，分别求解它们的LCS，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值