Gym 101986F Pizza Delivery（最短路+tarjan）

题意：一个有向图，n个点，m条边，1为起点，2为终点，问每次反转一条边的方向，最短路会不会发生改变，如果变短了，输出HAPPY，变长了或者到达不了了输出SAD，不变的话输出SOSO

先正向图跑一遍最短路，反向图也跑一遍最短路，对于一个边(u,v)，假如dis[u]+rev[v]+w==dis[2]，那么他就是最短路上的一条路径，用这些路径重新建一个图，跑一遍tarjan，对于一条边，如果dis[v]+rev[u]+w<dis[2]，那么就是HAPPY，否则是两种情况，第一种是如果这条边是桥，那么改变它的方向是会改变新图的连通性的，必定不能到达2点，所以是SAD，如果不是桥，那么就是SOSO，因为有别的方式可以到达

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<stack>
using namespace std;
typedef long long ll;
const int maxn=1e5+7;
const int maxm=2e5+7;
const ll inf=0x3f3f3f3f3f3f3f3f;
typedef pair<int,int> pii;
typedef pair<pii,ll> ppi;
typedef pair<ll,int> pli;
vector<ppi> G;
stack<int> sta;
bool edge_vis[maxm];
//--------------------dijkstra--------------------------
struct Node
{
	int to;
	ll val;
	int next;
}edge_dis[maxm],edge_rev[maxm];
int head_dis[maxn];//正向
int head_rev[maxn];//反向
int cnt_dis,cnt_rev;
ll dis[maxn],rev[maxn];
bool vis[maxn];
void init()
{
	memset(head_dis,-1,sizeof(head_dis));
	memset(head_rev,-1,sizeof(head_rev));
	cnt_dis=0;
	cnt_rev=0;
	return;
}
void add_dis(int u,int v,ll w)
{
	edge_dis[cnt_dis].to=v;
	edge_dis[cnt_dis].val=w;
	edge_dis[cnt_dis].next=head_dis[u];
	head_dis[u]=cnt_dis++;
	return;
}
void add_rev(int u,int v,ll w)
{
	edge_rev[cnt_rev].to=v;
	edge_rev[cnt_rev].val=w;
	edge_rev[cnt_rev].next=head_rev[u];
	head_rev[u]=cnt_rev++;
	return;
}
void dijkstra_dis()
{
	priority_queue<pli,vector<pli>,greater<pli> > que;
	dis[1]=0;
	que.push(make_pair(dis[1],1));
	memset(vis,false,sizeof(vis));
	while(!que.empty())
	{
		pii now=que.top();
		que.pop();
		int node=now.second;
		if(vis[node]) continue;
		vis[node]=true;
		for(int i=head_dis[node];~i;i=edge_dis[i].next)
		{
			int v=edge_dis[i].to;
			if(!vis[v]&&dis[v]>dis[node]+edge_dis[i].val)
			{
				dis[v]=dis[node]+edge_dis[i].val;
				que.push(make_pair(dis[v],v));
			}
		}
	}
	return;
}
void dijkstra_rev()
{
	priority_queue<pli,vector<pli>,greater<pli> > que;
	rev[2]=0;
	que.push(make_pair(rev[2],2));
	memset(vis,false,sizeof(vis));
	while(!que.empty())
	{
		pii now=que.top();
		que.pop();
		int node=now.second;
		if(vis[node]) continue;
		vis[node]=true;
		for(int i=head_rev[node];~i;i=edge_rev[i].next)
		{
			int v=edge_rev[i].to;
			if(!vis[v]&&rev[v]>rev[node]+edge_rev[i].val)
			{
				rev[v]=rev[node]+edge_rev[i].val;
				que.push(make_pair(rev[v],v));
			}
		}
	}
	return;
}
//-------------------dijkstra----------------------------
//--------------------tarjan-------------------------
struct LDJ
{
	int from;
	int to;
	ll val;
	int next;
	bool flag;
	int id;
}edge[maxm];
int cnt;
int idx;
int head[maxn];
int low[maxn];
int dfn[maxn];
void add(int u,int v,ll w,int id)
{
	edge[cnt].from=u;
	edge[cnt].to=v;
	edge[cnt].val=w;
	edge[cnt].next=head[u];
	edge[cnt].flag=false;
	edge[cnt].id=id;
	head[u]=cnt++;
	return;
}
void tarjan(int node,int pre)
{
	low[node]=dfn[node]=++idx;
	sta.push(node);
	vis[node]=true;
	for(int i=head[node];~i;i=edge[i].next)
	{
		int v=edge[i].to;
		if(v==pre) continue;
		if(!dfn[v])
		{
			tarjan(v,node);
			low[node]=min(low[node],low[v]);
			if(low[v]>dfn[node])
			{
				edge[i].flag=edge[i^1].flag=true;
				edge_vis[edge[i].id]=true;
			}
		}
		else if(vis[v]&&low[node]>dfn[v])
		{
			low[node]=dfn[v];
			//low[node]=min(low[node],dfn[v]);
		}
	}
	if(low[node]==dfn[node])
	{
		int v=-1;
		do
		{
			v=sta.top();
			sta.pop();
			vis[v]=false;
		}while(v!=node);
	}
	return;
}
//----------------------tarjan------------------------------
int main()
{
	//freopen("in.txt","r",stdin);
	//freopen("out.txt","w",stdout);
	int n,m;
	while(~scanf("%d%d",&n,&m))
	{
		init();
		G.clear();
		cnt=0;
		idx=0;
		while(!sta.empty()) sta.pop();
		memset(edge_vis,false,sizeof(edge_vis));
		memset(head,-1,sizeof(head));
		memset(dfn,0,sizeof(dfn));
		memset(low,0,sizeof(low));
		for(int i=0;i<m;i++)
		{
			int u,v;
			ll w;
			scanf("%d%d%lld",&u,&v,&w);
			G.push_back(make_pair(make_pair(u,v),w));
			add_dis(u,v,w);
			add_rev(v,u,w);
		}
		memset(dis,inf,sizeof(dis));
		memset(rev,inf,sizeof(rev));
		dijkstra_dis();
		dijkstra_rev();
		ll ans=dis[2];
		for(int i=0;i<m;i++)
		{
			int u=G[i].first.first;
			int v=G[i].first.second;
			ll w=G[i].second;
			if(dis[u]+rev[v]+w==ans)
			{
				add(u,v,w,i);
				add(v,u,w,i);
			}
		}
		memset(vis,false,sizeof(vis));
		for(int i=1;i<=n;i++)
		{
			if(!dfn[i])
			{
				tarjan(i,-1);
			}
		}
		for(int i=0;i<m;i++)
		{
			int u=G[i].first.first;
			int v=G[i].first.second;
			ll w=G[i].second;
			if(dis[v]+w+rev[u]<dis[2])
			{
				puts("HAPPY");
			}
			else
			{
				if(edge_vis[i])
				{
					puts("SAD");
				}
				else
				{
					puts("SOSO");
				}
			}
		}
	}
	return 0;
}