AtCoder Beginner Contest 404 C-G（无F）题解

C. Cycle Graph?

题意

给你一个 $N$ 个顶点 $M$ 条边的简单（无重边、自环）无向图，第 $i$ 条边连接节点 $A_i$ 和 $B_i$，判断这个图是不是一个环。

思路

首先一个图是环，要满足点数等于边数，即 $N=M$；

其次，这个图必须连通，可以通过 $\text{DFS}$ 或 $\text{BFS}$ 搜索判断是否连通（从任意一点开始搜，结束后检查是否每个点都已到达过）；

最后，每个点的度数（所连接的顶点数）必须为 $2$。

可以证明，只要满足上述三个条件，这个图一定是一个环。

C++ 代码

#include<bits/stdc++.h>

using namespace std;

const int maxn=200005;

int n,m;

int deg[maxn];

vector<int> g[maxn];

bool used[maxn];

void dfs(int v){

	used[v]=true;

	for(int x:g[v]){

		if(!used[x]){

			dfs(x);

		}

	}

}

int main(){

	cin>>n>>m;

	if(n!=m){

		cout<<"No\n";

		return 0;

	}

	for(int i=1;i<=m;i++){

		int u,v; cin>>u>>v;

		g[u].push_back(v);

		g[v].push_back(u);

	}

	dfs(1);

	for(int i=1;i<=n;i++){

		if(!used[i]||g[i].size()!=2){

			cout<<"No\n";

			return 0;

		}

	}

	cout<<"Yes\n";

	return 0;

}

D. Goin' to the Zoo

题意

$N$ 个动物园，动物园 $i$ 入场费为 $C_i$。$M$ 种动物，第 $j$ 种动物可以在共 $K_j$ 个动物园看到，分别为动物园 $A_{j,1},A_{j,2},\ ...,A_{j,K_j}$。

要看每种动物至少两次，至少花多少钱。

注：只要花一次 $C_i$，就可以进入动物园 $i$ 一次，就可以看里面的每个动物一次；若花两次，则可进入两次，看里面的动物两次

思路

由于 $N \le 10,M\le 100$，可以想到用状态压缩（不是dp）枚举。

状态压缩，就是把状态压缩到一个数字里

大致思路如下：

以 $140$ 为例，三进制数为 $12012$：

这样，$1\sim 3^N$ 的每个数字都有了实际含义

只要枚举 $1\sim3^N$ 的每个数，判断这样参观动物园能否达成“每种动物至少看两次”的目标，若可以，则记录答案，取最小值。

时间复杂度 $O(NM·3^N )$

C++ 代码

#include<bits/stdc++.h>

#define int long long

using namespace std;

const int inf=3e18;

const int maxn=1000005;

int c[maxn];

int k[105];

int v[105][105];

int mask[105];

int n,m;

signed main(){

	cin>>n>>m;

	for(int i=1;i<=n;i++){

		cin>>c[i];

	}

	for(int i=1;i<=m;i++){

		cin>>k[i];

		for(int j=0;j<k[i];j++){

			cin>>v[i][j];

		}

	}

	int ans=inf;

	for(int msk=0;msk<pow(3ll,n);msk++){

		memset(mask,0,sizeof(mask));//mask为当前数字所对应的三进制数

		int num=0;//num为花费

		int p=msk;

		for(int i=1;i<=n;i++){

			num+=(p%3)*c[i];

			for(int j=1;j<=m;j++){

				for(int a=0;a<k[j];a++){

					if(v[j][a]==i) mask[j]+=p%3;

				}

			}

			p/=3;

		}

		bool flag=true;

		for(int j=1;j<=m;j++){

            if(mask[j]<2) flag=false;

        }

		if(flag) ans=min(ans,num);

	}

	cout<<ans<<endl;

	return 0;

}

E. Bowls and Beans

题意

$N$ 个碗排成一排，编号为 $0\sim N-1$，碗 $i$ 中有 $A_i$ 个豆子，上面写着一个数字 $C_i$。

每次操作可以将碗 $i$ 里的豆子可以放到之前 $i-C_i \sim i-1$ 中的任意碗里，并且可以任意分配每个碗里放几颗。

最初碗 $0$ 中没有豆子，问：将所有豆子都移到碗 $0$ 中，最少需要多少步。

思路

贪心好像也可以，但是我不会！！

$N \le 2000$，考虑 $O(n^2)$ 动态规划。

动态规划基本三步：

设计 $\text{DP}$ 状态：

定义 $f_i$ 表示将编号 $\ge i$ 的所有碗中的豆子全部移到碗 $i$ 中的最小步骤；

初始化：

设最后一个有豆子的碗为 $p$，则对于 $i=p\sim n-1$，$f_i=0$（不需要操作），其余初始 $f_i=\infty$；

转移顺序及转移方程：

顺序：由于每个碗里的豆子只能往前移，为避免转移产生影响后续计算，应从后往前转移；

满足以下条件时，$f_i=\min(f_i,f_j+1)$：
- 条件1：$j>i$；
- 条件2：碗 $j$ 的豆子可以移到碗 $i$ 中，即$j-i \le C_j$；
- 条件3：若 $i-j\ge2$，$i+1$ 到 $j-1$ 之间的任何一个碗都没有豆子（否则不可能一步就完成 $j \rightarrow i$ 的操作）。

#include<bits/stdc++.h>

#define int long long

using namespace std;

const int inf=3e18;

const int maxn=2005;

int n;

int c[maxn],f[maxn];

bool a[maxn];

signed main(){

	cin>>n;

	for(int i=1;i<n;i++) cin>>c[i];

	for(int i=1;i<n;i++) cin>>a[i];

    //初始化

	for(int i=0;i<n;i++) f[i]=inf;

    int pos;

    for(int i=n-1;i>=0;i--){

        f[i]=0;

        if(a[i]){

            pos=i-1;

        	break;

        }

    }

    //转移

	for(int i=pos;i>=0;i--){//为了避免产生后效性，从后往前遍历

		for(int j=i+1;j<n;j++){//为了满足条件1，j=i+1开始

			if(j-i<=c[j]) f[i]=min(f[i],f[j]+1);//为了满足条件2

			if(a[j]) break;//为了满足条件3，只要遇到了有豆子的碗就退出

		}

	}

	cout<<f[0]<<endl;

	return 0;

}

G. Specified Range Sums

题意

有三个长度为 $M$ 的序列 $L,R,S$，你要判断是否存在一个长度为 $N$ 的 正整数 序列 $A$，满足以 $\sum_{j=L_i}^{R_i} A_j=S_i$。

若存在，找到最小的 $\sum_{j=1}^N A_j $；否则，输出 -1。

思路

首先，我们考虑将求和转换为前缀和，即定义 $C_i=\sum_{j=1}^iA_j$，则$C_{R_i}-C_{L_i-1}=S_i$。

建立有向图，顶点编号为 $0 \sim n$，这样连边：$(L_i-1,R_i)=S_i$，$(R_i,L_i-1)=-S_i$。另外，由于是正整数序列，所以 $(i+1,i)=-1$。

我们需要计算 $n \rightarrow 0$ 的最短路，答案即为这个值的相反数。

注意：无解时图中有负环，所以 $\text{Dijkstra}$ 不可以。考虑可以处理负环的 $\text{Bellman-Ford}$ 算法（不会没关系，下面讲）：

与图上动态规划相似，定义 $dis_i$ 表示从 $n$ 到 $i$ 的最短路，$dis_n=0$，其余为 $\infty$。

共进行 $N$ 次操作，每次操作如下：

对于每一条有向边 $(u,v)=w$，$dis_v=\min(dis_v,dis_u+w)$，共 $M$ 条边。

复杂度为 $O(NM)$，通常把上述操作称作 松弛(relax)。

在这 $N$ 次松弛之后，再执行第 $N+1$ 次操作，若还可以继续执行松弛操作，就说明图中存在负环，无解，输出 $-1$。

最终答案即为 $-dis_0$。

C++ 代码

#include<bits/stdc++.h>

#define int long long

using namespace std;

const int inf=3e18;

const int maxn=4005;

int n,m;

struct Node{

	int u,v,w;

};

vector<Node> v;

int dis[maxn];

signed main(){

	cin>>n>>m;

    //建图 连边

	for(int i=1;i<=m;i++){

		int l,r,s;

		cin>>l>>r>>s;

		v.pb({l-1,r,s});

		v.pb({r,l-1,-s});

	}

	for(int i=0;i<n;i++) v.pb({i+1,i,-1});

	//初始化

	for(int i=1;i<=n;i++) dis[i]=inf;

	dis[n]=0;

    //Bellman-Ford计算最短路  直接将第N+1次操作放入循环中

	for(int i=1;i<=n+1;i++){

		for(Node e:v){

			if(dis[e.v]>dis[e.u]+e.w){

				if(i==n+1){//若已经执行完n+1次松弛还可以继续执行，则无解

					cout<<-1<<endl;

					return 0l

				}

				dis[e.v]=dis[e.u]+e.w;

			}

		}

	}

	cout<<-dis[0]<<endl;

	return 0;

}