2017 暑假艾教集训 day12 网络流（最大流 最小割）！

最新推荐文章于 2021-07-17 14:11:43 发布
最新推荐文章于 2021-07-17 14:11:43 发布
阅读量245 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_36908995/article/details/77132005
版权

模板

using namespace std;
int n,m;
const int maxn=1005;
struct node
{
    int to,next,cap;
}edge[maxn<<2];
int head[maxn],cnt;
void add(int u,int v,int w)
{
    edge[cnt].to=v; edge[cnt].next=head[u];
    edge[cnt].cap=w;  head[u]=cnt++;
}
int deep[maxn];
int bfs(int s,int t)
{
    memset(deep,-1,sizeof(deep));
    deep[s]=0;
    queue<int> que;
    que.push(s);
    while(!que.empty())
    {
        int u=que.front(); que.pop();
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].to;
            if(deep[v]==-1 && edge[i].cap>0)
            {
                deep[v]=deep[u]+1;
                que.push(v);
            }
        }
    }
    return deep[t]!=-1;
}
int dfs(int u,int t,int maxflow)
{
    if(u==t || maxflow==0) return maxflow;
    int flow=0;
    for(int i=head[u];i!=-1; i=edge[i].next)
    {
        int v=edge[i].to;
        if(deep[v]==deep[u]+1 && edge[i].cap>0)
        {
            int temp = dfs(v,t,min(edge[i].cap,maxflow-flow) );
            if(temp)
            {
                edge[i].cap -=temp;
                edge[i^1].cap+=temp;
                flow += temp;
                if(maxflow==flow) break;
            }
        }
    }
    if(!flow) deep[u]=-1;
    return flow;
}
int dinic(int s,int t)
{
    int ans=0;
    while(bfs(s,t))
    {
        ans+=dfs(s,t,0x3f3f3f3f);
    }
    return ans;
}


POJ 1149
做法：建图是关键

建立超级起点汇点，每个顾客用一个点表示。
超级起点向每个猪圈第一个客人连猪圈的初始权值
每个猪圈的第I个客户向第I+1的客户连一条容量为inf 的边。
每个客户向超级汇点连一个容量为其最大购买容量的边！


POJ 1637
做法：存在欧拉回路的充要条件为每个点出入度相等，有向边无法改变方向对出入度影响是定值，重点在于无向边，初始时方向随意，若此时存在某点的出入度之差为奇数则不存在欧拉回路。设每个点出度-入度为x。 则该点的权值为x/2 。每改变一条相连的边出入度差值改变为2， 删除所有有向边，x/2>0与起点 连一条边，否则与汇点连一条边，如果最后满流这就说明了 存在欧拉回路 
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <queue>
using namespace std;
int n,m;
const int maxn=3005;
struct node
{
    int to,next,cap;
}edge[maxn<<2];
int head[maxn],cnt;
void add(int u,int v,int w)
{
    edge[cnt].to=v; edge[cnt].next=head[u];
    edge[cnt].cap=w;  head[u]=cnt++;
}
int deep[maxn];
int bfs(int s,int t)
{
    memset(deep,-1,sizeof(deep));
    deep[s]=0;
    queue<int> que;
    que.push(s);
    while(!que.empty())
    {
        int u=que.front(); que.pop();
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].to;
            if(deep[v]==-1 && edge[i].cap>0)
            {
                deep[v]=deep[u]+1;
                que.push(v);
            }
        }
    }
    return deep[t]!=-1;
}
int dfs(int u,int t,int maxflow)
{
    if(u==t || maxflow==0) return maxflow;
    int flow=0;
    for(int i=head[u];i!=-1; i=edge[i].next)
    {
        int v=edge[i].to;
        if(deep[v]==deep[u]+1 && edge[i].cap>0)
        {
            int temp = dfs(v,t,min(edge[i].cap,maxflow-flow) );
            if(temp)
            {
                edge[i].cap -=temp;
                edge[i^1].cap+=temp;
                flow += temp;
                if(maxflow==flow) break;
            }
        }
    }
    if(!flow) deep[u]=-1;
    return flow;
}
int dinic(int s,int t)
{
    int ans=0;
    while(bfs(s,t))
    {
        ans+=dfs(s,t,0x3f3f3f3f);
    }
    return ans;
}
int in[maxn],out[maxn];
void init()
{
    memset(head,-1,sizeof(head)); cnt=0;
    memset(out,0,sizeof(out));
    memset(in,0,sizeof(in));

    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;++i)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        in[b]++ ;out[a]++;
        if(c==0)
        {
            add(a,b,1); add(b,a,0);
        }
    }

}
int work()
{
    for(int i=1;i<=n;++i)
    {
        int temp=in[i]-out[i];
        if( (temp%2+2)%2==1) return 0;
    }

    int sum=0;
    for(int i=1;i<=n;++i)
    {
        int temp=out[i]-in[i];
        if(temp>0)
        {
            add(0,i,temp/2); add(i,0,0);

        }
        else if(temp<0)
        {
            temp= -temp;
            add(i,n+1,temp/2); add(n+1,i,0);sum+=(temp/2);
        }
    }
    if(sum==dinic(0,n+1)) return 1;
    return 0;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        init();
        if(work()) printf("possible\n");
        else printf("impossible\n");
    }
    return 0;
}

POJ 2391
做法：二分时间 检验的时候将小于mid的边都加入，判断是否满流即可（要用floyd求出各个点之间的最短路） 
#include <stdio.h>
#include <cstring>
#include <algorithm>
#include <queue>
#include <iostream>
using namespace std;
typedef  long long ll;
ll map[250][250];
int a[25000],b[25000],n,m,sum;
int s,t;
struct node
{
    int to,next,cap;
}edge[200*200*10];
int head[250*10],cnt,deep[250*10];

void add(int u,int v,int w)
{
    edge[cnt].to=v; edge[cnt].next=head[u];
    edge[cnt].cap=w;  head[u]=cnt++;
}
int bfs(int s,int t)
{
    memset(deep,-1,sizeof(deep));
    deep[s]=0;
    queue<int> que;
    que.push(s);
    while(!que.empty())
    {
        int u=que.front(); que.pop();
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].to;
            if(deep[v]==-1 && edge[i].cap>0)
            {
                deep[v]=deep[u]+1;
                que.push(v);
            }
        }
    }
    return deep[t]!=-1;
}
int dfs(int u,int t,int maxflow)
{
    if(u==t || maxflow==0) return maxflow;
    int flow=0;
    for(int i=head[u];i!=-1; i=edge[i].next)
    {
        int v=edge[i].to;
        if(deep[v]==deep[u]+1 && edge[i].cap>0)
        {
            int temp = dfs(v,t,min(edge[i].cap,maxflow-flow) );
            if(temp)
            {
                edge[i].cap -=temp;
                edge[i^1].cap+=temp;
                flow += temp;
                if(maxflow==flow) break;
            }
        }
    }
    if(!flow) deep[u]=-1;
    return flow;
}
void gettu(ll mid)
{
    s=0; t=2*n+1;
    memset(head,-1,sizeof(head));
    cnt=0;
    for(int i=1;i<=n;++i)
    {
        add(s,i,a[i]);  add(i,s,0);
        add(i+n,t,b[i]);    add(t,i+n,0);
    }
    for(int i=1;i<=n;++i)
    {
        for(int j=1;j<=n;++j)
        {
            if(map[i][j]<=mid)
            {
                add(i,j+n,0x3f3f3f3f);
                add(j+n,i,0);
            }
        }
    }
}
int dinic(ll mid)
{
    gettu(mid);
    int ans=0;
    while(bfs(s,t))
    {
        ans+=dfs(s,t,0x3f3f3f3f);
    }
    if(ans==sum) return 1;
    return 0;
}

int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        sum=0;
        for(int i=1;i<=n;++i)
        {
            for(int j=1;j<=n;++j)
            {
                map[i][j]=1LL<<60;
            }
            map[i][i]=0;
        }
        for(int i=1;i<=n;++i)
        {
            scanf("%d%d",&a[i],&b[i]);
            sum+=a[i];
        }
        for(int i=0;i<m;++i)
        {
            int x,y; ll w;
            scanf("%d%d%lld",&x,&y,&w);
            if(map[x][y]>w)
            {
                map[x][y]=map[y][x]=w;
            }
        }
        ll maxn=0;
        for(int i=1;i<=n;++i)
        {
            for(int j=1;j<=n;++j)
            {
                for(int k=1;k<=n;++k)
                {
                    map[j][k] = min(map[j][k],map[j][i]+map[i][k]);
                    if(map[j][k]!=(1LL<<60)) maxn=max(maxn,map[j][k]);
                }
            }
        }

        ll l=0,r=maxn+5, ans=-1,mid;
        while(r>=l)
        {
            mid=(l+r)/2;
            gettu(mid);
            if(dinic(mid)) { r=mid-1; ans=mid; }
            else  l=mid+1;
        }
        printf("%lld\n",ans);
    }
}


最小割：

Hoj：2634

做法：最大权闭合子图问题，答案为 all（权值）-最小割==最大流

#include <cstring>
#include <cstdio>
#include <cmath>
#include <queue>
#include <algorithm>
typedef long long ll;
using namespace std;
int n,m;
const int maxn=10000;
struct node
{
    int to,next,cap;
}edge[maxn<<2];
int head[maxn],cnt;
void add(int u,int v,int w)
{
    edge[cnt].to=v; edge[cnt].next=head[u];
    edge[cnt].cap=w;  head[u]=cnt++;
}
int deep[maxn];
int bfs(int s,int t)
{
    memset(deep,-1,sizeof(deep));
    deep[s]=0;
    queue<int> que;
    que.push(s);
    while(!que.empty())
    {
        int u=que.front(); que.pop();
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].to;
            if(deep[v]==-1 && edge[i].cap>0)
            {
                deep[v]=deep[u]+1;
                que.push(v);
            }
        }
    }
    return deep[t]!=-1;
}
int dfs(int u,int t,int maxflow)
{
    if(u==t || maxflow==0) return maxflow;
    int flow=0;
    for(int i=head[u];i!=-1; i=edge[i].next)
    {
        int v=edge[i].to;
        if(deep[v]==deep[u]+1 && edge[i].cap>0)
        {
            int temp = dfs(v,t,min(edge[i].cap,maxflow-flow) );
            if(temp)
            {
                edge[i].cap -=temp;
                edge[i^1].cap+=temp;
                flow += temp;
                if(maxflow==flow) break;
            }
        }
    }
    if(!flow) deep[u]=-1;
    return flow;
}
int dinic(int s,int t)
{
    int ans=0;
    while(bfs(s,t))
    {
        ans+=dfs(s,t,0x3f3f3f3f);
    }
    return ans;
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&m,&n);
        memset(head,-1,sizeof(head));
        cnt=0;

        int sum=0,a;
        for(int i=1;i<=m;++i)
        {
            scanf("%d",&a);
            add(0,i,a); add(i,0,0);
            sum+=a;
        }
        for(int i=1;i<=n;++i)
        {
              scanf("%d",&a);
              add(i+m,n+m+1,a); add(n+m+1,i+m,0);
        }
        for(int i=1;i<=m;++i)
        {
             int k;
             scanf("%d",&k);
             while(k--)
             {
                 scanf("%d",&a);
                 add(i,a+m+1,0x3f3f3f3f);
                 add(a+m+1,i,0);
             }
        }
        printf("%d\n",sum-dinic(0,n+m+1));
    }
    return 0;
}

Hoj2713

做法：二分图最大点权独立集；（如同黑白染色）

注意： 二分图最大点权独立集+二分图最小点权覆盖集==ALL 

#include <iostream>
#include <stdio.h>
#include <cstring>
#include <queue>

using namespace std;
int n,m,sum;
const int maxn=3000;
struct node
{
    int to,next,cap;
}edge[1000001];
int head[maxn],cnt;
void add(int u,int v,int w)
{
    edge[cnt].to=v; edge[cnt].next=head[u];
    edge[cnt].cap=w;  head[u]=cnt++;
}
int deep[maxn];
int bfs(int s,int t)
{
    memset(deep,-1,sizeof(deep));
    deep[s]=0;
    queue<int> que;
    que.push(s);
    while(!que.empty())
    {
        int u=que.front(); que.pop();
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].to;
            if(deep[v]==-1 && edge[i].cap>0)
            {
                deep[v]=deep[u]+1;
                que.push(v);
            }
        }
    }
    return deep[t]!=-1;
}
int dfs(int u,int t,int maxflow)
{
    if(u==t || maxflow==0) return maxflow;
    int flow=0;
    for(int i=head[u];i!=-1; i=edge[i].next)
    {
        int v=edge[i].to;
        if(deep[v]==deep[u]+1 && edge[i].cap>0)
        {
            int temp = dfs(v,t,min(edge[i].cap,maxflow-flow) );
            if(temp)
            {
                edge[i].cap -=temp;
                edge[i^1].cap+=temp;
                flow += temp;
                if(maxflow==flow) break;
            }
        }
    }
    if(!flow) deep[u]=-1;
    return flow;
}
int dinic(int s,int t)
{
    int ans=0;
    while(bfs(s,t))
    {
        ans+=dfs(s,t,0x3f3f3f3f);
    }
    return ans;
}


int in[60][60];
int g[60][60];
int dir[4][2]= { {1,0} , {-1,0} , {0,-1} , {0,1} };
int id;
bool check(int x,int y)
{
    if(x<=0||y<=0||x>n||y>m)  return 0;
    return 1;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {

        memset(in,0,sizeof(in));
        id=0;
        sum=0;
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;++i)
        {
            for(int j=1;j<=m;++j)
            {
                ++id;
                scanf("%d",&g[i][j]);
                in[i][j]=id;
                sum+=g[i][j];
            }
        }

        memset(head,-1,sizeof(head));
        cnt=0;
        int s=0,t=n*m+1;

        for(int i=1;i<=n;++i)
        {
            for(int j=1;j<=m;++j)
            {
                int id=in[i][j];
                if((i+j)&1)
                {
                    add(id,t,g[i][j]); add(t,id,0);
                }
                else
                {
                    add(s,id,g[i][j]);
                    add(id,s,0);
                    for(int k=0;k<4;++k)
                    {
                       int x= i +dir[k][0];
                       int y= j +dir[k][1];
                       if(!check(x,y)) continue;
                       add(id,in[x][y],0x3f3f3f3f); add(in[x][y],id,0);
                    }
                }
            }
        }

        printf("%d\n",sum-dinic(s,t));
    }
    return 0;
}





【NOIP 2016】普及组第二轮题解
weixin_42596089的博客
10-12 553
【NOIP 2016】普及组第二轮题解
HDU 1011 (树背包)
morejarphone~
11-18 325
坑点是特判。 #include using namespace std; #define maxn 111 #define maxm 222 struct node { int from, to, next; }edge[maxm]; int bug[maxn], brain[maxn]; int n, m, head[maxn]; int ans; int dp[maxn][max
2017 暑假艾教集训 day6
小菜鸟。。
08-07 277
CF 240F 做法：二维线段树，分别记录一个区间的小写字母个数，每次从小到大给两边分配（字典序最小）（区间更改）！ #include #define lson rt<<1,begin,mid #define rson rt<<1|1,mid+1,end using namespace std; const int maxn= 100100; char str[maxn];
2017 暑假艾教集训 day4
小菜鸟。。
08-05 387
题库： https://cn.vjudge.net/contest/176263#overview A：HDU 40704 做法：相当于将 n 任意组合， 可能的情况为 2^(n-1)，因为n会很大，使用欧拉降幂公式 B：Given A,B,C, You should quickly calculate the result of A^B mod C. (1 做法：同上题一样算出C
2017 暑假艾教集训 day1
小菜鸟。。
08-02 237
1.蓄水池问题 http://acm.nyist.net/JudgeOnline/problem.php?pid=547 做法：先把池子的四周用优先队列存起来，枚举每个点向四个方向延伸（注意vis数组），如果拓展点的高度小于当前节点的高度 ans+=（H[now]-H[ex]） 并且把拓展点的高度改为当前点的高度  否则直接扔进队列即可， a.UvaLive 7147 做法：做过第
2017 暑假艾教集训 day8 （补一道思维题，
小菜鸟。。
08-10 237
HDU 2615 做法：好好读题！！！。当时晚上做的，完全不知道在写什么。 首先第一刀切任何地方都有可能， 所以先暴力枚举第一刀。 而第二刀就不同了，这里第二个人是有智慧的，会切一刀使他得到的最大，只需要在第一重循环下开一个maxtwo变量即可，同时当答案相同时，第三个人取最小答案。 wa点 第二刀枚举的时候应该在第一刀的左右都要枚举。 n很小，只要读懂题就可以暴力过 #in
2017 暑假艾教集训 day10 AC自动机+马拉车+后缀数组 +kmp
小菜鸟。。
08-10 467
https://vjudge.net/contest/177933#overview H HDU3068 做法：马拉车模板 #include using namespace std; const int maxn= 110015; char s[maxn]; char str[maxn*2]; int dp[maxn*2]; int mlc() { int n=strlen(s+
2017 暑假艾教集训 day9(整体二分 + cdq分治 cdq真是我女神！！！)
小菜鸟。。
08-10 293
POJ 2104 求第k小 做法：整体二分加树状数组。 离线把询问和插入做整体二分，每次把s，t扫一般 如果是插入就在线段树上相应的位置插入（val，1）。 对于每个询问查询在l，r 中 用多少个数 如果加上累加的数 小于k那么 答案应该在右区域把该询问扔到右区域 并把查询的结果累加（左区间本来有查询结果个前k小，直接进入右边会少算）。 如果大于 k 的话那么答案应该在左端扔进左端
暑期集训Day9总结（最大流与费用流）
star_moon0309的博客
08-10 203
最近一直在讲图论，今天讲了网络流，题目注定不好写（代码巨长）。。。 昨天下午打多校，导致做题拖了很多进度，到昨天晚上才做4道。。。 尽管网络流的知识本身很难，比如说Dinic算法和费用流的算法到现在也没有完全搞明白，不过并不要紧，暂时把它看成一个黑盒吧 （窝太弱了。。。）而重要的是如何建图。一旦能够建出合适的图，再套一下模板，这道题就迎刃而解了。 下面看几道例题： -----------...
2019暑假集训DAY4（problem3.construct）（网络流）
weixin_30413739的博客
07-13 99
改编自BZOJ2521 [Shoi2010]最小生成树 题面 1 construct 1.1 Description Me懒得编题面了 给出一个n个点m条边的图，每条边有边长。现在我们钦定了一条边，要使该边一定出现在最小生成树中 你可以进行如下操作：将某条边的长度+1，并付出1的代价 最少需要付出多少代价可以满足要求呢？ 1.2 Input 第一...
2021-07-17 JZYZ暑期集训Day12 资源分配类DP，背包问题总结
qq_35684989的博客
07-17 732
Day12资源分配机器分配猫棚背包问题0/1背包问题！ 资源分配 这类问题就是要把一些资源分给一些公司（人）。不同的分配方法会带来不同的效益，求解怎么样分配才最优。 机器分配 题目描述 某总公司拥有高效生产设备M台，准备分给下属的N个分公司。各分公司若获得这些设备，可以为总公司提供一定的盈利。问：如何分配这M台设备才能使公司得到的盈利最大？求出最大盈利值。 分配原则：每个公司有权获得任意数目的设备，但总台数不得超过总设备数M。其中M<=100，N<=100。M<=100
2021-07-09 JZYZ暑期集训Day3 贪心进阶总结
qq_35684989的博客
07-09 646
Day3独木舟删数问题最大整数排队接水【单调队列】合并果子最大子序列和【邻项交换】大神排队 贪心是一种想法，仔细看来并不是一种算法。 实际生活中，经常需要求一些问题的“可行解”和“最优解”，这就是所谓的“最优化”问题。 一般来说，每个最优化问题都包含一组“限制条件”和一个“目标函数”，符合限制条件的问题求解方案称为可行解，使目标函数取得最佳值（最大或最小）的可行解称为最优解。 求解最优化问题的算法很多，例如穷举、搜索、动态规划等。贪心法也是求解这类问题的一种常用方法。 独木舟 【问题描述】 旅行社计划组织一
【2020暑期海亮集训】Day 1：从枚举到DFS模拟赛（7.17）
Admin-zx 的博客
08-30 585
目录题目T1-及格 pass题目描述输入格式输出格式样例输入样例输出数据规模解题思路Code24点 24题目描述输入格式输出格式样例输入样例输出解题思路Code 题目 T1-及格 pass 题目描述 小A这学期上了一门课，这门课分数的评定标准如下： 课程分数=x∗a%+y∗b%+z∗(100−a−b)%=x*a\%+y*b\%+z*(100-a-b)\%=x∗a%+y∗b%+z∗(100−a−b)% 其中 xxx 为平时作业成绩、yyy 为期中考试成绩、zzz 为期末考试成绩， x,y,z,a,b,100−
17天正睿集训总结
qq_40681184的博客
07-28 949
【写在前面】   "正睿普及=IOI"是常识    这里开始亲身17天体验     ——来自蒟蒻的微笑(*￣︶￣) 持续更新中 - 已完成 1/17 7.28-Day0 集训拉开序幕。 首先签字（转：" 宁可做大佬也不可做CXK "，一群人纷纷在大佬区签了字）+ 拿CXK专属纪念T恤+开始点外卖。 8：00 开始为时半个小时的开会，老师洪亮的声音让我们认清现实： 准备好爆 0 吧。 老师继续...
野生动物目标检测数据集.zip
05-15
数据集介绍：野生动物目标检测数据集 一、基础信息 数据集名称：野生动物目标检测数据集 图片数量： - 训练集：4,181张图片 - 验证集：1,212张图片 - 测试集：610张图片 总计：6,003张航拍及自然场景图片 分类类别： 涵盖23类野生动物，包括： - 濒危物种（北极熊、犀牛、熊猫） - 大型哺乳动物（大象、河马、长颈鹿） - 猛禽类（鹰、鹦鹉、企鹅） - 食肉动物（狮子、猎豹、美洲豹） - 草食动物（斑马、鹿、山羊） 标注格式： YOLO格式标注，包含边界框坐标与类别标签，适配主流目标检测框架。 数据特性： 航拍视角与地面视角相结合，包含动物群体活动和个体行为场景。 二、适用场景 生态保护监测系统： 构建野生动物种群识别系统，支持自然保护区自动监测动物迁徙和栖息地活动。 智能林业管理： 集成至森林巡护无人机系统，实时检测濒危物种并预警盗猎行为。 动物行为研究： 为科研机构提供标注数据支撑，辅助研究动物种群分布与行为特征。 自然纪录片制作： AI预处理工具开发，快速定位视频素材中的特定物种片段。 教育科普应用： 用于野生动物识别教育软件，支持互动式物种学习功能开发。 三、数据集优势 物种覆盖全面： 包含非洲草原系、极地系、森林系等23类特色动物，特别涵盖10种IUCN红色名录物种。 多场景适配： 整合航拍与地面视角数据，支持开发不同观测高度的检测模型。 标注质量可靠： 经动物学专家校验，确保复杂场景（群体/遮挡）下的标注准确性。 模型兼容性强： 原生YOLO格式可直接应用于YOLOv5/v7/v8等系列模型训练。 生态研究价值： 特别包含熊科动物（棕熊/北极熊/熊猫）细分类别，支持濒危物种保护研究。
云计算的起源与发展.pptx
最新发布
05-15
云计算的起源与发展.pptx
软件工程过程资料模板界面设计说明书.doc
05-15
软件工程过程资料模板界面设计说明书.doc
职称计算机xp题库.doc
05-15
职称计算机xp题库.doc
网站运营管理手册.docx
05-15
网站运营管理手册.docx
2009年成都大学ACM暑期集训教程与参考书目
"这是关于2009年四川大学暑期ACM集训计划的详细内容，主要涉及编程竞赛的准备和学习资源。集训计划参考了成都大学的相关资料，并提供了丰富的书籍列表供学员深入学习。训练内容包括基础算法、数据结构、组合数学等多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值