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\sim 3^N$ 的每个数，判断这样参观动物园能否达成“每种动物至少看两次”的目标，若可以，则记录答案，取最小值。

时间复杂度 $O(NM\cdot 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)$ 动态规划。

动态规划基本三步：

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

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

2. 初始化：

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

3. 转移顺序及转移方程：

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

   满足以下条件时，$f_i=\min (f_i,f_j+1)$：

   • 条件1：$j>i$；

   • 条件2：碗 $j$ 的豆子可以移到碗 $i$ 中，即$j-i\le C_j$；

   • 条件3：若 $i-j\ge 2$，$i+1$ 到 $j-1$ 之间的任何一个碗都没有豆子（否则不可能一步就完成 $j\to i$ 的操作）。

C++ 代码

#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}^i{A}_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\to 0$ 的最短路，答案即为这个值的相反数。

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

与图上动态规划相似，定义 $di{s}_i$ 表示 从 $n$ 到 $i$ 的最短路，$di{s}_n=0$，其余为 $\infty$。

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

• 对于每一条有向边 $(u,v)=w$，$di{s}_v=\min (di{s}_v,di{s}_u+w)$，共 $M$ 条边。

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

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

最终答案即为 $-di{s}_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.push_back({l-1,r,s});
		v.push_back({r,l-1,-s});
	}
	for(int i=0;i<n;i++) v.push_back({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 0;
				}
				dis[e.v]=dis[e.u]+e.w;
			}
		}
	}
	cout<<-dis[0]<<endl;	
	return 0;
}