P3367
并查集：
#include <iostream>
using namespace std;
int n,m;
int z,x,y;
int p[10005];
int find(int a){
if(p[a]==a) return a;
else return p[a]=find(p[a]); //find(p[p[a]]) 递归都是n层复合函数
}
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++){
p[i]=i;
}
while(m--){
cin>>z>>x>>y;
if(z==1){
p[find(x)]=find(y);
} else if(z==2){
if(find(x)==find(y)) cout<<'Y'<<'\n';
else if(find(x)!=find(y)) cout<<'N'<<'\n';
}
}
return 0;
}
P8604
要统计 从a到b 所有道路中都经过的点 只要这个点在（a,b）道路上出现次数 和(a,b)道路总条数想通就行。dfs遍历所有a到b的道路 一边统计边数 每经过一条边统计边上某个点的出现次数
#include <iostream>
#define LL long long
using namespace std;
const int maxn=1010;
LL n, m;
bool map[maxn][maxn], visit[maxn]; //map[maxn][maxn]是否为0 能不能走得通 vist[maxn]=0是否走过 &&
LL sum, cnt[maxn];
LL a, b;
LL u, v;
void dfs(int now){
if(now==b){
sum++; //路径条数
for(int i=1;i<=n;i++){
if(visit[i]==1) cnt[i]++; //总共有n个点所以一维就可以 visit[i]和cnt[i]有对应关系吗？？？
}
}
else {
for(int i=1;i<=n;i++){ //圈闭搜索底下的 有 而且没走过的话
if(map[now][i]==1 && visit[i]==0)
visit[i]=1;
dfs(i);
visit[i]=0;
}
}
}
int main(){
scanf("%d%d", &n, &m);
for(int i=0;i<m;i++){
cin>>u>>v;
map[u][v]=map[v][u]=1;
}
scanf("%d%d", &a, &b);
dfs(a);
int ans=0;
if(sum>0){
for(int i=1;i<=n;i++){
if(sum==cnt[i]) ans++;
printf("%d", ans-1); //减去最后一个点
}
}
else printf("-1");
return 0;
}
P1330
相邻的概念是两个大点之间有一个边连接就是相邻。
由于随便一条边都可以构成一个道路所以随便一条边都要被封锁。
这样的话需要同时满足： 所有编制少一个顶点被和谐站上 并且两个同时站不行
所以随便一个遍端点有且仅有一个点能被和谐占上
将任意一条边按照二分图分， 好比把任意一条边两个顶点都要染成不同颜色 但总共所有点只能被染成两种颜色
1 是否可以分成二分图？ 用染色法判断
2 如果不是-1 吐过是：分成二分图其中那个点数较小的集合的点数就是要用到最少的河蟹数
#include<cstdio>
#include<iostream>
#include<cmath>
#include<string>
#include<string>
#include<algorithm>
using namespace std;
struct Edge
{
int tt;
int nexty;
}edge[200000];
int head[20000];
int cnt=0;//链式前向星
void add(int a,int b)//存边
{
cnt++;
edge[cnt].tt=b;
edge[cnt].nexty=head[a];
head[a]=cnt;
}
bool used[20000]={0};//是否遍历过
int col[20000]={0};//每一个点的染色
int sum[2];//黑白两种染色各自的点数
bool dfs(int node,int color)//染色（返回false即impossible）
{
if(used[node])//如果已被染过色
{
if(col[node]==color)return true;//如果仍是原来的颜色，即可行
return false;//非原来的颜色，即产生了冲突，不可行
}
used[node]=true;//记录
sum[col[node]=color]++;//这一种颜色的个数加1，且此点的颜色也记录下来
bool tf=true;//是否可行
for(int i=head[node];i!=0&&tf;i=edge[i].nexty)//遍历边
{
tf=tf&&dfs(edge[i].tt,1-color);//是否可以继续染色
}
return tf;//返回是否完成染色
}
int main()
{
int n,m;
scanf("%d%d",&n,&m);
int a,b;
while(m--)
{
scanf("%d%d",&a,&b);
add(a,b);
add(b,a);//存的是有向边，所以存两次
}
int ans=0;
for(int i=1;i<=n;i++)
{
if(used[i])continue;//如果此点已被包含为一个已经被遍历过的子图，则不需重复遍历
sum[0]=sum[1]=0;//初始化
if(!dfs(i,0))//如果不能染色
{
printf("Impossible");
return 0;//直接跳出
}
ans+=min(sum[0],sum[1]);//加上小的一个
}
printf("%d",ans);//输出答案
return 0;
}
p3916
因为是编号最大的点 可以每个点遍历所有的可走路径并且更新重点编号的最大值
更省时间： 以从大到小编号开始遍历 到的重点所对应的最大编号就是起点存到这些点中 这些点
由于是有向图 我们需要反向存边 这样可以从最大编号的点往回遍历（就是走原本以标号小的点为出发点的通路的反向通路） 如果这个点被遍历过了 那么就不用进行存储操作了
#include <iostream>
#include <vector>
#define maxn 100010
using namespace std;
int n, m, A[maxn]; //A[i]正向的时候一个点出发终点的最大值
vector<int> G[maxn];
void dfs(int x, int d){
if(A[x]) return; //从x出发 访问过 立刻结束 不要往下走
A[x]=d; //那它经过得所有边都被标上了？？？
for(int i=0;i<G[x].size();i++) // 以它能爱投的所欲道德边遍历
{
dfs(G[x][i], d);
}
}
int main(){
scanf("%d%d", &n, &m);
for(int i=1;i<=m;i++){
int u, v;
cin>>u>>v;
G[v].push_back(u); //反向存边 比如说一个v对应着多条边 那么g[i][0]=v1; g[i][1]=v2; g[i][2]=v3......
}
for(int i=n; i>=1; i--){
dfs(i, i);
}
for(int i=1;i<=n;i++){
printf("%d ", A[i]);
}
return 0;
}
可以一个点神搜 搜到底 然后记录编号最大的点
但是更快的神搜方法是： 从编号大的点往下搜 搜到所有它能到达的终点 这个终点能走到最远的就是这个点
如何保证：那就是最大的点往下搜完了那些搜到的终点在搜索更小答辩哈欧典为起点的时候 以他们的为重点的边就不算上了
反向建边得到
并不一定非要反向到达
p1119
考察floyd求最短路的过程的实质：
第k次遍历仅允许以1~k为中转
这个也一样第t天之前只允许1~t天建好的村庄可以为中转更新每天的最短路径图谱
可以以天数为k进行floyd，对于输入的要求天数 每次只用floyd更新到这一天就行了
如果其中一个建成的天数大于所要求的天数 那么cout impossible
#include <iostream>
#include <algorithm>
#define inf 1e9
#defien maxn 205
int n, m, t;
int u, v, w;
int map[maxn][maxn];
int a[maxn]; //时间
inline void update(int k){ //inline是一种以空间换时间的做法，省去调用函数额外开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
map[i][j]=min(map[i][j], map[i][k]+map[k][j]);
return;
}
int main(){
cin>>n>>m;
for(int i=1;i<=n;i++){
scanf("%d", a+i);
}
for(int i=0;i<=n;i++){
for(int j=0;j<=n;j++){
map[i][j]=inf;
}
map[i][i]=0;
}
// int main(){
// cin>>n>>m;
// for(int i=0;i<n;i++){
// scanf("%d", a+i);
// }
//
// for(int i=1;i<=n;i++){
// for(int j=1;j<=n;j++){
// map[i][j]=inf;
// }
// map[i][i]=0;
// }
//
// int s1, s2, s3;
// while(m--){
// cin>>s1>>s2>>s3;
// f[s1][s2]=f[s2][s1]=s3;
// }
//
int q;
cin>>q;
int now=0;
int s1, s2, s3;
while(q--){
cin>>s1>>s2>>s3;
while(a[now]<s3 && now<n){ //n个点顶多n天 为什么是n啊？？？
update(now);
now++;
}
if(a[s1]>s3 || a[s2]>s3){
cout<<"-1"<<endl;
} else cout<<f[s1][s2]<<endl;
}
return 0;
}
int q;
cin>>q;
while(q--){
cin>>s1>>s2>>s3;
while(a[now]<=s3 && now<n){ //在最后到之前以及到指定时间之前只要没有update就update 因为时间递增 很良心 不用存储拍虚了
updata(now);
now++;
}
if(a[s1]>s3 || a[s2]>s3) cout<<-1<<endl; //村子还没有建好
} else cout<<map[s1][s2]<<endl; //update之后的最短路径长
return 0;
}
P1525
怨气值从大到小排序， 每一个点先边遍历到的是和自己怨气最大的 ， 那就将这个标记为自己的敌人，不能喝他分到一起。敌人的敌人和自己并。
#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<queue>
#include<cstring>
using namespace std;
typedef long long ll;
const int inf=1e9+7;
inline int read()
{
int p=0,f=1;char c=getchar();
while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
while(c>='0'&&c<='9'){p=p*10+c-'0';c=getchar();}
return f*p;}
const int N=20009;
const int M=200019;
struct Edge//定义边:起点nex,终点to,边权w
{
int nex,to,w;
}p[M];
int n,m,fa[N],Enemy[N];
//fa[i]是i的父亲(并查集),Enemy[i]是i的敌人(不能在同一组)
int find(int k)//并查集找父亲
{
if(fa[k]==k)return k;
else return fa[k]=find(fa[k]);
}
bool cmp(Edge x,Edge y)
{return x.w>y.w;}
int main()
{
n=read(),m=read();
for(int i=1;i<=m;i++)//加边
p[i].nex=read(),
p[i].to=read(),
p[i].w=read();
for(int i=1;i<=n;i++)
fa[i]=i;
sort(p+1,p+1+m,cmp);//按怒气值从大到小排序
//接下来开始合并罪犯
for(int i=1;i<=m;i++)
{
int t1=find(p[i].nex),t2=find(p[i].to);
if(t1==t2)//出现矛盾:直接结束
{
printf("%d",p[i].w);
return 0;
}
//其余的就把敌人的敌人与自己分到一组
if(!Enemy[p[i].nex])
Enemy[p[i].nex]=p[i].to;
else fa[find(Enemy[p[i].nex])]=find(p[i].to);
//同上
if(!Enemy[p[i].to])
Enemy[p[i].to]=p[i].nex;
else fa[find(Enemy[p[i].to])]=find(p[i].nex);
}
printf("0");//没有矛盾
return 0;
}
P3386
二分图匹配：
#include <cstdio>
#include <vector>
const int maxn = 1005;
int n, m, t;
int mch[maxn], vistime[maxn];
std::vector<int> e[maxn];
bool dfs(const int u, const int tag);
int main() {
scanf("%d %d %d", &n, &m, &t);
for (int u, v; t; --t) {
scanf("%d %d", &u, &v);
e[u].push_back(v);
}
int ans = 0;
for (int i = 1; i <= n; ++i) if (dfs(i, i)) {
++ans;
}
printf("%d\n", ans);
}
bool dfs(const int u, const int tag) {
if (vistime[u] == tag) return false;
vistime[u] = tag;
for (auto v : e[u]) if ((mch[v] == 0) || dfs(mch[v], tag)) {
mch[v] = u;
return true;
}
return false;
}
p1129
由题意得，我们可以对任意两行或两列进行交换操作。
我们考虑将每一行的行数与该行黑色方块所在的列数连一条边。
然后可以将它进行如下图的变化得到答案
我们可以看出，右图中的每一行列都至少有一个符合的匹配（显然）。
进而我们思考，是否是每一行列至少存在一组合法匹配的图形合法呢？
答案是的
因为任意两行或者任意两列之间的交换都不会破坏他们的平衡性。
也就是说， 任意2个黑色方块， 如果它们初始状态是不在同一行（列）， 那么无论怎么交换，他们都不会在同一行（列）
所以我们可以得到第一种解法 匈牙利二分图匹配解法。
#include<cstdio>
#include<cstring>
#define LL long long
#define Sets(s,v) memset(s,v,sizeof(s))
using namespace std;
inline LL read(){
LL ans=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-'){f=-1;}ch=getchar();}
while(ch>='0'&&ch<='9'){ans=(ans<<3)+(ans<<1)+(ch^48);ch=getchar();}
return ans*f;
}
void write(LL x){
if(x<0){putchar('-');x=-x;}
if(x>9){write(x/10);}
putchar(x%10|48);
}
struct Edge{
int next,v;
}edge[40005];
int head[205],cnt;
int mark[205],match[205],tim;
inline void add(int u,int v){
cnt++;
edge[cnt].next=head[u];
edge[cnt].v=v;
head[u]=cnt;
return;
}
inline void flush(){
Sets(head,0);
Sets(mark,0);
Sets(match,0);
tim=0;
cnt=0;
return;
}
int augment(int u){
for (int i=head[u];i;i=edge[i].next){
int v=edge[i].v;
if(mark[v]==tim) continue;
mark[v]=tim;
if(match[v]==0||augment(match[v])){
match[v]=u;
return true;
}
}
return false;
}
inline int hungarian(int n){
int res=0;
for (int i=1;i<=n;i++){
tim++;
if(augment(i)){
res++;
}
}
return res;
}
int main(){
int T=read();
while(T--){
flush();
int n=read();
for (int i=1;i<=n;i++){
for (int j=1;j<=n;j++){
int t=read();
if(t){
add(i,j);
}
}
}
printf("%s\n",hungarian(n)==n?"Yes":"No");
}
return 0;
}
2910
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
