虫洞路线（最短路）

N个虫洞，M条单向跃迁路径。从一个虫洞沿跃迁路径到另一个虫洞需要消耗一定量的燃料和1单位时间。虫洞有白洞和黑洞之分。设一条跃迁路径两端的虫洞质量差为delta。

1.从白洞跃迁到黑洞，消耗的燃料值减少delta，若该条路径消耗的燃料值变为负数的话，取为0。

2.从黑洞跃迁到白洞，消耗的燃料值增加delta。

3.路径两端均为黑洞或白洞，消耗的燃料值不变化。

作为压轴题，自然不会是如此简单的最短路问题，所以每过1单位时间黑洞变为白洞，白洞变为黑洞。在飞行过程中，可以选择在一个虫洞停留1个单位时间，如果当前为白洞，则不消耗燃料，否则消耗s[i]的燃料。现在请你求出从虫洞1到N最少的燃料消耗，保证一定存在1到N的路线。

从题目可以得知这是一条最短路的问题

大致可以概括为三个操作

1. 两个类型一样的点之间进行操作，代价就是边权
2. 两个不同类型的点之间进行操作，代价可能是边权±点质量差
3. 自己和自己操作，代价为一个s[i]或者0

并且每个点的类型都在0/1之间不断变化（每个时间单位变化一次）

30pts 暴搜

暴枚每一种操作，找到终点就打擂台
#include<bits/stdc++.h>
#define maxn 5500
using namespace std;
inline int read()
{
	int res=0,f=1;char ch=getchar();
	while(!isdigit(ch)){if(ch=='-')f=-f;ch=getchar();}
	while(isdigit(ch)){res=(res<<1)+(res<<3)+(ch&15);ch=getchar();}
	return res*f;
}
int n,m,w[maxn],a[maxn],s[maxn];
int edge[maxn][maxn];
int vis[maxn];
int ans=1e7;
int  num[maxn];
inline bool bai (int x,int t)
{
	if((t+a[x])%2)return 0;
	return 1;
}
inline bool bla(int x,int t)
{
	if((t+a[x])%2)return 1;
	return 0;
}
inline void dfs(int x,int time,int val,int f)
{
	num[time]=x;
	if(x==n)
	{
		ans=min(ans,val);
		return;
	}
	for(int i=1;i<=n;i++)
	{
		if(!vis[i]&&edge[x][i])
		{
			vis[i]=1;
			if(bai(x,time)&&bla(i,time))
			{
				int v=abs(w[x]-w[i]);
				int w=max(0,edge[x][i]-v);
				dfs(i,time+1,val+w,0);
			}
			else 
			{
				if(bla(x,time)&&bai(i,time))
				{
				int v=abs(w[x]-w[i]);
				dfs(i,time+1,val+edge[x][i]+v,0);
				
			    }
			    else dfs(i,time+1,val+edge[x][i],0);
			}
			vis[i]=0;
		}
	}
	if(!f)
	{
	if(bai(x,time))dfs(x,time+1,val,1);
	else dfs(x,time+1,val+s[x],1);
	}
}
int main()
{
	n=read();m=read();
	for(int i=1;i<=n;i++)a[i]=read();
	for(int i=1;i<=n;i++)w[i]=read();
	for(int i=1;i<=n;i++)s[i]=read();
	for(int i=1;i<=m;i++)
	{
		int u,v,k;
		u=read();v=read();k=read();
		edge[u][v]=k;
	}
	vis[1]=1;
	dfs(1,0,0,0);
	cout<<ans;
	return 0;
}

100pts

只有两种状态所以，可以把n的序列拆开成n*2的序列，那么对此进行相互建边就可以表示所有的状态

1~n 为原来的序列
n+1~2*n 为原来序列的相反点

对于题目要求就可以建边了，在建好边之后就出现了最基础的最短路模型
spfa一遍就好了

#include<bits/stdc++.h>
#define maxn 15000
#define maxm 75000
using namespace std;
inline int read()//读优 
{
	int res=0,f=1;char ch=getchar();
	while(!isdigit(ch)){if(ch=='-')f=-f;ch=getchar();} 
	while(isdigit(ch)){res=(res<<1)+(res<<3)+(ch&15);ch=getchar();} 
	return res*f;
}
int head[maxn],tot,n,m,col[maxn];
int s[maxn],w[maxn];
struct node{ 
	int to;int next;
	int val;
}edge[maxm];
inline void add(int x,int y,int z)
{
	edge[++tot].to=y;
	edge[tot].val=z;
	edge[tot].next=head[x];
	head[x]=tot;
}
queue<int>q;
int dis[maxn],vis[maxn];
inline void spfa()//最短路板子 
{
	
	memset(dis,0x3f,sizeof(dis));

	dis[1]=0;vis[1]=1;
	q.push(1);
	while(!q.empty())
	{
		int k=q.front();q.pop();
		vis[k]=0;
	    for(int i=head[k];i;i=edge[i].next)
	    {
	    	int to=edge[i].to;
	    	if(dis[to]>dis[k]+edge[i].val)
	    	{
	    		dis[to]=dis[k]+edge[i].val;
	    		if(!vis[to])
	    		{
	    			vis[to]=1;
					q.push(to); 
				}
			}
		}
	}
}
int main()
{
	n=read();m=read();
    for(int i=1;i<=n;i++)col[i]=read();// 0/1 白洞 黑洞 
	for(int i=1;i<=n;i++)w[i]=read();//   每个洞的质量 
	for(int i=1;i<=n;i++)s[i]=read();//  停留的代价 
	for(int i=1;i<=m;i++)
	{
		int u,v,z;
		u=read();v=read();z=read();
		if(col[u]==col[v])//相同的情况是不需要代价的 
		{
		add(u,v+n,z);
		add(u+n,v,z);
		}
        else 
        {
        	int d=abs(w[u]-w[v]);
        	if(col[u]) // u 为黑洞 u+n 为白洞 
        	{
        		add(u,v+n,z+d);//  黑洞到白洞 加上代价 
        		add(u+n,v,max(z-d,0));// 反正则是白洞到黑洞 
			}
			else //同上 
			{
				add(u,v+n,max(z-d,0));
        		add(u+n,v,z+d);
			}
		}
	}	
	for(int i=1;i<=n;i++)
	{
		if(!col[i])
		{
			add(i+n,i,s[i]);//自己的情况 
			add(i,i+n,0);
		}
		else 
		{
			add(i,i+n,s[i]);
			add(i+n,i,0);
		}
	}
	spfa();
	cout<<min(dis[n],dis[2*n]);//答案就在走到最后一个点 
	return 0;
}