2018"百度之星"程序设计大赛 - 资格赛 1001状压 1002 前缀和 1003 BFS寻路的KM算法 1005 dp+树状数组 1006最小生成树

最新推荐文章于 2024-08-15 10:59:29 发布
最新推荐文章于 2024-08-15 10:59:29 发布
阅读量1k 收藏
点赞数
分类专栏： 最小生成树 树状数组 排序 贪心 DP 二分图
本文为博主原创文章，未经博主允许也可以转载。
本文链接：https://blog.csdn.net/frankax/article/details/81448139
版权
贪心 同时被 3 个专栏收录
66 篇文章 0 订阅
订阅专栏
DP
21 篇文章 0 订阅
订阅专栏
排序
19 篇文章 0 订阅
订阅专栏

1001
题意：给n份问卷，每个问卷m道题，每题只有A，B两种选项，问存在多少个问题集合，使得只保留这些问题后至少k对卷子不同。
思路：状压，最大只有（1<<10),用二进制表示选择了哪些题，转为数字，统计这个数字出现的次数 num , num * ( n - num ) 就是这个集合对 不同卷子对数 贡献的2倍，除以2（去重），跟k比较。
Code：

#include <bits/stdc++.h>
using namespace std;
const int AX = 1024;
int a[AX];
char s[AX][20];
int b[AX][20];
unordered_map<int,int>mp;
int main(){
    int T;
    scanf("%d",&T);
    int n , m , k ;
    int Case = 0 ;
    while( T-- ){
        int res = 0 ;
        scanf("%d%d%d",&n,&m,&k);
        for( int i = 0 ; i < n ;  i++ ){
            scanf("%s",s[i]);
        }
        int MAX = ( 1 << m );
        for( int i = 1 ; i < MAX ; i++ ){
            int tot = 0 ;
            for( int j = 0 ; j < m ; j++ ){
                if( i & ( 1 << j ) ){
                    for( int kk = 0 ; kk < n ; kk++ ){
                        b[kk][tot] = s[kk][j] - 'A';
                    }
                    tot ++;
                }
            }
            for( int j = 0 ; j < n ; j++ ){
                a[j] = 0 ;
                for( int kk = 0 ; kk < tot ; kk++ ){
                    a[j] <<= 1 ;
                    a[j] |= b[j][kk];
                }
            }
            mp.clear();
            for( int kk = 0 ; kk < n ; kk++ ){
                mp[a[kk]] ++;
            }
            int tmp = 0; 
            for( auto kk : mp ){
                tmp += ( n - kk.second ) * kk.second;
            }
            if( tmp / 2 >= k ) res ++;
        }
        printf("Case #%d: %d\n", ++Case, res);
    }
    return 0 ; 
}

1002
思路：前缀和维护即可。
Code：

#include <bits/stdc++.h>
using namespace std;
const int AX = 1e5+66;
int sum[AX][30];
char s[AX];
int main(){
    int T;
    scanf("%d",&T);
    int Case = 0; 
    while( T-- ){
        memset( sum , 0 , sizeof(sum) );
        int n , q ;
        scanf("%d%d",&n,&q);
        scanf("%s",s+1);
        int l , r ;
        for( int i = 1 ; i <= n ; i++ ){
            int id = s[i] - 'A';
            for( int j = 0 ; j < 26 ; j++ ){
                if( id == j ) sum[i][id] = sum[i-1][id] + 1 ;
                else sum[i][j] = sum[i-1][j] ; 
            }
        }
        printf("Case #%d:\n",++Case);
        while( q -- ){
            scanf("%d%d",&l,&r);
            for( int i = 0 ; i < 26 ; i++ ){
                if( sum[r][i] - sum[l-1][i] ){
                    printf("%d\n",sum[r][i] - sum[l-1][i]);
                    break;
                }
            }
        }
    }
    return 0 ;
}

1003
题意：看作是二分图，那么本题就是求顶标和的最大值，也就是最小权匹配
思路：bfs实现的KM算法求最小权匹配，先取负值，求出最大权匹配后，取反即可。
Code：

#include <bits/stdc++.h>
#pragma comment(linker, “/STACK:1024000000,1024000000”)
#define INF 1e9
#define LL long long
using namespace std;
const int AX = 3e2+6;
LL w[AX][AX];
LL lx[AX] , ly[AX];
int linker[AX];
LL slack[AX];
int n ;
bool visy[AX];
int pre[AX];
void bfs( int k ){
    int x , y = 0 , yy = 0 , delta;
    memset( pre , 0 , sizeof(pre) );
    for( int i = 1 ; i <= n ; i++ ) slack[i] = INF;
    linker[y] = k;
    while(1){
        x = linker[y]; delta = INF; visy[y] = true;
        for( int i = 1 ; i <= n ;i++ ){
            if( !visy[i] ){
                if( slack[i] > lx[x] + ly[i] - w[x][i] ){
                    slack[i] = lx[x] + ly[i] - w[x][i];
                    pre[i] = y; 
                }
                if( slack[i] < delta ) delta = slack[i] , yy = i ;
            }
        }
        for( int i = 0 ; i <= n ; i++ ){
            if( visy[i] ) lx[linker[i]] -= delta , ly[i] += delta;
            else slack[i] -= delta;
        }
        y = yy ;
        if( linker[y] == -1 ) break;
    }
    while( y ) linker[y] = linker[pre[y]] , y = pre[y];
}

void KM(){
    memset( lx , 0 ,sizeof(lx) );
    memset( ly , 0 ,sizeof(ly) );
    memset( linker , -1, sizeof(linker) );
    for( int i = 1 ; i <= n ; i++ ){
        memset( visy , false , sizeof(visy) );
        bfs(i);
    }
}

int main(){
    int T;
    scanf("%d",&T);
    int Case = 0 ;
    LL x ;
    while( T-- ){
        scanf("%d",&n);
        for( int i = 1 ; i <= n ; i++ ){
            for( int j = 1 ; j <= n ; j++ ){
                scanf("%lld",&x);
                w[i][j] = 0 - x ;
            }
        }
        KM();
        LL res = 0 ;
        for( int i = 1 ; i <= n ; i++ ){
            if( linker[i] != -1 ){
                res += w[linker[i]][i] ;
            }
        }
        printf("Case #%d: %lld\n",++Case,0-res);
    }
    return 0 ;
}

1005
题意：1-n的随机排列，问长度为k的上升子序列数分别为多少。
思路：首先会容易想到一个O(n^3) 的dp：
dp[ i ][ j ] = Σ ( 1 <= k <= j ) dp[i-1] [ k ] ( a[k] < a[j] )
dp[i][j] 表示以a[j]结尾长度为i的上升序列个数。

但是题目的n是1e4数量级的，会T.
然后我想用二维树状数组对于每个j建立一个树状数组，维护dp[i][j]前缀和又MLE了。
请教了别人后发现可以在加一个滚动数组减少树状数组维护的工作量，
最后用一维树状数组维护每次长度以a[j]结尾的前缀和，然后加个dp[][j]滚动数组记录以a[j]结尾的长度 i 的序列个数.
复杂度就转化成n*n*logn（其实应该还好点，听大佬说是sqrt(n)*n*logn）。
我多写个memset就TLE了。。以后不该写的代码不要写。。
Code：

#include <bits/stdc++.h>
#pragma comment(linker, “/STACK:1024000000,1024000000”)
#define INF 0x3f3f3f3f
#define LL long long
using namespace std;
const int AX = 1e4;
const int MOD = 1e9+7;
int a[AX];
int c[AX];
int dp[2][AX];
int n ;
int lowbit(int x){
    return x&(-x);
}
void update( int value , int site ){
    while( site <= n ){
        c[site] = ( 0LL + c[site] + value ) % MOD;
        site += lowbit(site);
    }
}
int getsum(int i){
    int sum = 0;
    while( i >= 1 ){
        sum = ( 0LL + sum + c[i] ) % MOD ;
        i -= lowbit(i);
    }
    return sum ;
}

int main(){
    int T;
    scanf("%d",&T);
    int Case = 0 ;
    while( T-- ){
        memset( dp, 0 , sizeof(dp) );
        scanf("%d",&n);
        int cur = 0 ;
        for( int i = 1 ; i <= n ; i ++ ){
            scanf("%d",&a[i]); 
            dp[cur][i] = 1 ;
        }
        printf("Case #%d: ",++Case);
        printf("%d",n);
        int f = 1 ;
        for( int i = 2 ; i <= n ; i++ ){
            cur = !cur;
            LL ans = 0LL ;
            if( f ){
                memset( c , 0 , sizeof(c) );
                for( int j = 1 ; j <= n ; j ++ ){
                    dp[cur][j] = getsum( a[j] - 1 ) % MOD;
                    ans = ( ans + dp[cur][j] ) % MOD;
                    update( dp[!cur][j] , a[j] );
                }
            }
            if( !ans ) f = 0; 
            printf(" %d",ans%MOD);
        }
        printf("\n");
    }
    return 0 ;
}

1006

思路：分别求红绿和蓝绿的最短路，然后前n-2条边肯定是不能组成n个点的最小生成树，所以都输出-1，然后分别求出每个最小生成树没有用过的边，排个序，最后就比较两个最小生成树加1，2…条边后谁更小，就输出谁。
Code:

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
const int AX = 1e2+66;
struct Node{
    int u , v , w ;
    int id ;
    bool friend operator < ( const Node &a , const Node &b ){
        return a.w < b.w ;
    }
}a[AX] , b[AX] , c[AX];
int pa[AX];
int pb[AX];
int vis[5][AX];
Node roada[AX];
Node roadb[AX];
int n , m ;
int tot1 , tot2;
void init(){
    for( int i = 1 ; i <= n ; i++ ){
        pa[i] = i ; pb[i] = i ;
    }
    memset( vis , 0 , sizeof(vis) );
    tot1 = 0 ;
    tot2 = 0 ;
}

int find_a( int x ){
    return x == pa[x] ? pa[x] : pa[x] = find_a(pa[x]);
}

int find_b( int x ){
    return x == pb[x] ? pb[x] : pb[x] = find_b(pb[x]);
}

void mix_a( int x , int y ){
    int xx = find_a(x); int yy = find_a(y);
    if( xx != yy ) pa[yy] = xx ;
}

void mix_b( int x , int y ){
    int xx = find_b(x); int yy = find_b(y);
    if( xx != yy ) pb[yy] = xx ;
}

int Kruscal( Node *e , int k , int id ){
    int ans = 0 ;
    int nEdge = 0 ;
    sort( e , e + k );
    for( int i = 0 ; i < k ; i++ ){
        if( !id ){
            if( find_a(e[i].u) != find_a(e[i].v) ){
                mix_a( e[i].u , e[i].v );
                ans += e[i].w;
                vis[id][e[i].id] = 1 ;
                nEdge ++;
            }
        }else{
            if( find_b(e[i].u) != find_b(e[i].v) ){
                mix_b( e[i].u , e[i].v ); 
                ans += e[i].w;
                vis[id][e[i].id] = 1 ;
                nEdge ++;
            }
        }
    }
    if( nEdge < n - 1 ) ans = INF ;
    return ans ;
}

int main(){
    int T;
    scanf("%d",&T);
    int Case = 0 ;
    while( T-- ){
        scanf("%d%d",&n,&m);
        init();
        char col[5];
        for( int i = 1 ; i <= m ; i++ ){
            scanf("%d%d%d%s",&c[i].u,&c[i].v,&c[i].w,col);
            if( col[0] == 'R' || col[0] == 'G' ){
                a[tot1].u = c[i].u ; a[tot1].v = c[i].v; a[tot1].w = c[i].w ; a[tot1++].id = i;
            }        
            if( col[0] == 'B' || col[0] == 'G' ){
                b[tot2].u = c[i].u ; b[tot2].v = c[i].v; b[tot2].w = c[i].w ; b[tot2++].id = i;
            }
        }
        int ans = Kruscal(a,tot1,0);
        int ans1 = Kruscal(b,tot2,1);

        int num = 0 ;
        int cnt = 0 ;

        for( int i = 1 ; i <= m ; i++ ){
            if( !vis[0][i] ){
                roada[num++] = c[i];
            }
        }
        sort( roada , roada + num );

        for( int i = 1 ; i <= m ; i++ ){
            if( !vis[1][i] ){
                roadb[cnt++] = c[i];
            }
        }
        sort( roadb , roadb + cnt ) ;

        printf("Case #%d:\n",++Case);
        if( ans1 == INF && ans == INF ){
            for( int i = 0 ; i < m ; i++ ){
                printf("-1\n");
            }continue;
        }
        for( int i = 1 ; i < n - 1 ; i++ ){
            printf("-1\n");
        } 
        printf("%d\n",min(ans1,ans));
        int t = 0 ;
        int t1 = 0 ;
        for( int i = n ; i <= m ; i++ ){
            ans += roada[t++].w;
            ans1 += roadb[t1++].w;
            printf("%d\n",(ans<ans1?ans:ans1));
        }
    }
    return 0 ;
}
Dave_L
关注
专栏目录
KM_KM算法_C++_ACM_
09-29
本代码为基于BFS的KM算法，复杂度为O(n^3)
二分图的最佳完美匹配--KM算法（DFS寻路+BFS寻路(O(n^3))） + HDU2255入门题
Dave_lzw的博客
08-09 1737
Reference Blog： 原理清晰深刻：https://blog.csdn.net/sixdaycoder/article/details/47720471 较容易于理解：https://www.cnblogs.com/wenruo/p/5264235.html 如果二分图的每条边都有一个权（可以是负数），要求一种完备匹配方案，使得所有匹配边的权和最大，记做最佳完美匹配。（特殊的...
学计算机必参加的含金量赛事！但凡参加一个面试都要简单一倍
最新发布
2401_84578953的博客
08-15 1354
现在计算机相关的赛事数不胜数，但含金量较高的比赛却只有那么几项，做好了你现场就能找到工作，就算是考研也是益处很大，今天给大家总结出来。就别再折腾一些费时费力但又不讨好的比赛了。
【原创】KM算法的Bfs写法
致上
06-16 5799
KM算法的Bfs写法引入–DfsKM的时间复杂度我们已经学习了KM算法，现在我们来分析一下它的时间复杂度。bool dfs(int s) { visx[s]=1; for(int i=1;i<=cnty;i++) if(!visy[i]) { int t=wx[s]+wy[i]-dis[s][i]; i
二分图最大权匹配【KM算法 BFS优化下的真正的O(N3)的KM算法】【KM算法模板】
既然弱小，就只顾变强就是了
12-04 1854
很多人都知道的，要想真正知道你的KM算法是不是真实的，那么不妨用这道题来验证： UOJ #80. 二分图最大权匹配 如果你使用的是DFS，那么你的代码会TLE在第38组： #include <iostream> #include <cstdio> #include <cmath> #include <string> #include &l...
KM算法（DFS版，优化DFS版，BFS版）
h_bby的博客
11-17 2665
KM算法主要用于二分图的最大权匹配问题 图解 模板 如果我们要求边权值最小的匹配可以把边权值取负值，得出结果后再取相反数即为答案。 KM算法各版本模板： dfs版KM算法模板O(n4)复杂度 图解+模板 题集 对访问过且匹配过的男生，期望值要加上女生减去的期望值；代码中的未访问过的男生实际上包含两种，一种是完全没被访问过的（slack[ j ] = INF），一种是访问过，且更新过slack值但没有参与匹配的男生，由于这种男生可匹配的部分女生期望值降低，所以该男生的slack值减少。 HDU 2255 模板
计算机大赛-团体程序设计天梯赛算法范围.docx
04-21
### 计算机大赛-团体程序设计天梯赛算法范围详解 #### 一、排序算法 排序算法是在程序设计竞赛中极为重要的基础算法之一。它不仅能够帮助我们组织数据，还能为后续处理提供便利。 - **冒泡排序**：通过重复地走访...
数据结构课程设计之图的遍历和生成树求解
10-14
数据结构课程设计中，图的遍历和生成树求解是重要的主题，涉及到图的存储结构、遍历算法以及最小生成树的计算。以下是这些知识点的详细说明： 1. **图的存储结构**： - **邻接矩阵**：对于无向图，邻接矩阵是一个n...
PHP树的深度编历生成迷宫及A*自动寻路算法实例分析
10-24
在本文中，我们将深入探讨如何使用PHP实现基于树的深度遍历生成迷宫以及A*自动寻路算法。这两种技术在游戏开发、路径规划和其他需要寻找最优路径的场景中非常常见。 首先，我们来看树的深度遍历生成迷宫的方法。...
图+查找+排序+循环链表+循环链表+数组+广义表+二叉树与树的转换+哈夫曼树.pptx
11-10
在IT领域，数据结构与算法是基础且至关重要的部分，它们直接影响到程序的效率和设计。这份名为"图+查找+排序+循环链表+循环链表+数组+广义表+二叉树与树的转换+哈夫曼树.pptx"的文档涵盖了多个关键知识点，下面将对...
km算法对最大全职匹配bfs算法的解释理解 n^3
qqqingyi的博客
02-08 252
#include<cstdio> #include<iostream> #include<cstring> #include<algorithm> using namespace std; typedef long long ll; const int N = 510,INF = 1e18; ll n,m; ll a[N][N]; ll ex[N],ey[N],visy[N],now; ll match[N],pre[N],slack[N]; v
二分图最大权匹配（完美匹配）——KM算法模板（dfs版O(n^4) + bfs版O(n^3)）
weixin_45925735的博客
08-02 779
写在前面： 考虑到二分图中两个集合中的点并不总是相同，为了能应用 KM算法解决二分图的最大权匹配，需要先作如下处理： 将两个集合中点数比较少的补点，使得两边点数相同，再将不存在的边权重设为 0，这种情况下，问题就转换成求最大权完美匹配问题 ，从而能应用KM算法求解。 具体算法流程： (1)分配可行顶标，对每个顶标执行(2)(3)(4) (2)匈牙利算法找到增广路 (3)找不到增广路就调整顶标。 (4)重复(2)，(3)直到找到增广路 模板题：P6577 【模板】二分图最大权完美匹配 DFS版本： #incl
【学习笔记】KM 算法
七代目鸽影
02-04 533
就这么个玩意儿，耗费了我两三天，恐怖如斯！
【数据关联（3）】​5月9日数据匹配图论、匈牙利、KM算法,多目标跟踪
Hali_Botebie的博客
05-09 2143
总体目标 二分图博客推荐 匈牙利算法步骤 匈牙利算法博客推荐 KM算法步骤 KM算法标杆(又名顶标)的引入 KM流程详解 KM算法博客推荐 贪心算法 英文注解 无权二分图（unweighted bipartite graph）的最大匹配（maximum matching）和完美匹配（perfect matching），以及用于求解匹配的匈牙利算法（Hungarian Algorithm） 背景知识...
二分图带权最大匹配-KM算法详解
EQUINOX1的博客
01-15 2666
找不到对象就降低期望（
算法总结篇——BFS
纪宁的博客
04-21 2123
BFS是广度优先搜索（Breadth-First Search）的缩写，是一种图遍历算法。它从给定的起始节点开始，逐层地向外扩展，先访问起始节点的相邻节点，然后再访问相邻节点的相邻节点，以此类推，直到遍历完所有可达节点。创建一个队列，并将起始节点入队；将起始节点标记为已访问；当队列不为空时，循环执行以下操作： a. 出队一个节点；b. 访问该节点；c. 将该节点的所有未访问相邻节点入队，并标记为已访问；遍历完成。
Going Home 【HDU - 1533】【KM算法】
既然弱小，就只顾变强就是了
12-18 188
有N个房子，N个人，每个人到房子都有对应的路径，问每个人去往不同的房子居住，所需要的最短的路径。 很显然，求最小权完美匹配问题，直接把边设置为负数，然后跑一遍KM即可，此处用的是BFS优化的KM算法。 #include <iostream> #include <cstdio> #include <cmath> #include <string>...
【算法笔记】二分图最大权匹配 - KM算法（dfs版O(n4) + bfs版O(n3)）
繁凡さん的博客
10-09 1186
匈牙利算法又称为 KM 算法，可以在 O(n3)O(n^3)O(n3) 时间内求出二分图的 最大权完美匹配 。 考虑到二分图中两个集合中的点并不总是相同，为了能应用 KM 算法解决二分图的最大权匹配，需要先作如下处理：将两个集合中点数比较少的补点，使得两边点数相同，再将不存在的边权重设为 0，这种情况下，问题就转换成求最大权完美匹配问题 ，从而能应用 KM\tt KMKM 算法求解。 其实就是普通的匈牙利算法求二分图最大匹配的拓展版本 顶标：两边点都有的标记（左 aia_iai​右 bjb_jbj​）满
C#实现Prim算法：最小生成树与深度/广度优先遍历
最小生成树 --Prim算法是一种在图论中用于寻找一个无向加权图的最小生成树的算法，它由计算机科学家克劳德·艾利奥特·普里姆(Claude Elwood Shannon Prim)于1957年提出。在实际应用中，比如城市规划、网络设计或...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值