Submission #201160

#	Time	Username	Problem	Language	Result	Execution time	Memory
201160		zscoder	Olympic Bus (JOI20_ho_t4)	C++17	37 / 100	1088 ms	13788 KiB

ho_t4

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
 
using namespace std;
using namespace __gnu_pbds;
 
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define fbo find_by_order
#define ook order_of_key
 
typedef long long ll;
typedef pair<ll,ll> ii;
typedef vector<int> vi;
typedef long double ld; 
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
set<int> S;

struct Graph
{
	struct edge
	{
		int v; ll weight; int id;
	};
	vector<vector<edge> > adj;
	int n;
	
	Graph(int _n)
	{
		adj.resize(_n);
		n = _n;
	}
	
	void addedge(int u, int v, ll c, int id)
	{
		edge tmp;
		tmp.v = v; tmp.weight = c; tmp.id=id;
		adj[u].pb(tmp);
	}
	
	void reset()
	{
		adj.clear();
	}
	
	vector<ll> dist;
	vi par;
	
	void bfs(int s)
	{
		ll INFI = ll(1e18);
		dist.assign(n, INFI);
		par.assign(n, -1);
		dist[s] = 0; par[s] = -1;
		queue<int> q; q.push(s);
		while(!q.empty())
		{
			int u = q.front(); q.pop();
			for(int i = 0; i < adj[u].size(); i++)
			{
				int v = adj[u][i].v;
				if(dist[v] >= INFI)
				{
					dist[v] = dist[u] + 1;
					par[v] = u;
					q.push(v);
				}
			}
		}
	}
	
	void bfs01(int s)
	{
		ll INFI = ll(1e18);
		dist.assign(n, INFI);
		par.assign(n, -1);
		dist[s] = 0; par[s] = -1;
		deque<int> q; q.pb(s);
		while(!q.empty())
		{
			int u = q.front(); q.pop_front();
			for(int i = 0; i < adj[u].size(); i++)
			{
				int v = adj[u][i].v; ll w = adj[u][i].weight;
				if(dist[v] >= INFI)
				{
					if(w == 1)
					{
						dist[v] = dist[u] + 1;
						par[v] = u;
						q.push_back(v);
					}
					else
					{
						dist[v] = dist[u];
						par[v] = u;
						q.push_front(v);
					}
				}
			}
		}
	}
	
	void dijkstra(int s, int mode=1)
	{
		ll INFI = ll(1e18);
		dist.clear();
		dist.assign(n, INFI);
		par.assign(n, -1);
		dist[s] = 0; par[s] = -1;
		priority_queue<ii, vector<ii>, greater<ii> > pq;
		pq.push(ii(0, s));
		while(!pq.empty())
		{
			int u = pq.top().se; ll d = pq.top().fi; pq.pop();
			for(int i = 0; i < adj[u].size(); i++)
			{
				int v = adj[u][i].v; ll w = adj[u][i].weight;
				if(d + w < dist[v])
				{
					dist[v] = d + w;
					par[v] = u;
					pq.push(ii(dist[v], v));
				}
			}
		}
	}
	
	vector<vector<ll> > d;
	
	void Floyd()
	{
		ll INFIN = ll(1e18);
		d.resize(n);
		for(int i = 0; i < n; i++)
		{
			d[i].assign(n, INFIN);
		}
		for(int i = 0; i < n; i++)
		{
			for(int j = 0; j < adj[i].size(); j++)
			{
				d[i][adj[i][j].v] = min(d[i][adj[i][j].v],adj[i][j].weight);
			}
			d[i][i] = 0;
		}
		for(int k = 0; k < n; k++)
		{
			for(int i = 0; i < n; i++)
			{
				for(int j = 0; j < n; j++)
				{
					d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
				}
			}
		}
	}
};

const int MAXV = 200;		// maximum value of vertex
const ll INF = ll(1e18)+10;		// infinity value used instead of INT_MAX for relax may overflow
const int INVALID = 0xDEADF00D;	// special value to record negetive cycle condiction

class LIB_SPFA{
public:

	LIB_SPFA(int v=MAXV, int e=MAXV*(MAXV-1)) 
		: neg_cycle(false), checked_start(INVALID), Vnum(v), Enum(e), edge(Vnum+1), prev(Vnum+1), dis(Vnum+1)
	{}

	void add_edge(int src, int dst, int weight)
	{
		edge[src].push_back(EDGE(dst,weight));

		checked_start = INVALID;
	}

	bool contains_neg_cycle(int src=1)
	{
		if(checked_start == INVALID)
			SPFA(src);
		return neg_cycle;
	}

	ll get_dis(int src, int dst)
	{
		if(contains_neg_cycle(src))
			return INVALID;
		if(checked_start != src)
			SPFA(src);
		return dis[dst];
	}

	const vector<int>& getPrev() const {return prev;}

	struct EDGE{
		EDGE(int n, int w):next(n),w(w){}
		int next, w;
	};//C++ struct is already a type

	bool neg_cycle;
	int checked_start;

	int Vnum, Enum;
	vector< vector<EDGE> > edge;
	vector<int> prev;
	vector<ll> dis;

	void SPFA(int start)
	{
		int i;
		int nowv, nextv, siz;
		queue<int> check;
		vector<int> count(Vnum+1);
		vector<bool> inqueue(Vnum+1);

		checked_start = start;

		fill(prev.begin(), prev.begin()+Vnum+1, -1);
		fill(dis.begin(), dis.begin()+Vnum+1, INF);

		fill(inqueue.begin(), inqueue.begin()+Vnum, false);
		fill(count.begin(), count.begin()+Vnum, 0);

		dis[start] = 0;
		check.push(start);
		inqueue[start] = true;
		count[start]++;

		while(!check.empty()){
			nowv = check.front();
			check.pop();
			inqueue[nowv] = false;
			siz = edge[nowv].size();
			for(i=0;i<siz;i++){
				nextv = edge[nowv][i].next;
				if(dis[nextv] > dis[nowv] + edge[nowv][i].w){
					dis[nextv] = dis[nowv] + edge[nowv][i].w;
					prev[nextv] = nowv;
					if(!inqueue[nextv]){
						check.push(nextv);
						inqueue[nextv] = true;
						count[nextv]++;
						if(count[nextv] >= Vnum ){

							neg_cycle = true;

							return ;
						}
					}
				}
			}
		}

		neg_cycle = false;
	}
};


ll D[55555];
vector<pair<ii,ii> > edges;
int n,m; 
ll res=ll(1e18);
ll adj[222][222];

void test(int id)
{
	Graph G(n);
	LIB_SPFA sG(n);
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<n;j++)
		{
			adj[i][j]=ll(1e18);
			if(i==j) adj[i][j]=0;
		}
	}
	for(int i=0;i<m;i++)
	{
		int u=edges[i].fi.fi; int v=edges[i].fi.se;
		if(i==id) swap(u,v);
		adj[u][v]=min(adj[u][v],edges[i].se.fi);
	}
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<n;j++)
		{
			if(i!=j&&adj[i][j]<ll(1e18)) sG.add_edge(i,j,adj[i][j]);
			//G.addedge(u,v,edges[i].se.fi,edges[i].se.se);
		}
	}
	//G.dijkstra(0,0);
	//ll ans = G.dist[n-1];
	//G.dijkstra(n-1,0);
	//ans+=G.dist[0];
	ll ans = sG.get_dis(0,n-1)+sG.get_dis(n-1,0);
	ans+=D[id];
	res=min(res,ans);
}

int main()
{
	ios_base::sync_with_stdio(0); cin.tie(0);
	//freopen("olympic-bus.in","r",stdin);
	cin>>n>>m;
	Graph ori(n),oriunw(n),oriunw2(n);
	vector<ii> VV;
	int all0=1;
	map<ii,ii> ma;
	for(int i=0;i<m;i++)
	{
		int u,v,c,d;
		cin>>u>>v>>c>>d;
		if(c!=0) all0=0;
		VV.pb({c+d,i});
		u--; v--;
		if(ma.find({u,v})==ma.end())
		{
			ma[{u,v}]={c+d,i};
		}
		else
		{
			ma[{u,v}]=min(ma[{u,v}],{c+d,i});
		}
		D[i]=d;
		edges.pb({{u,v},{c,d}});
		ori.addedge(u,v,c,i);
		oriunw.addedge(u,v,c,i);
		oriunw.addedge(v,u,c+d,i);
		oriunw2.addedge(v,u,c,i);
		oriunw2.addedge(u,v,c+d,i);
	}
	int sub2=1;
	if(m%2==0)
	{
		for(int i=0;i<m;i+=2)
		{
			int a1 = edges[i].se.se;
			int a2 = edges[i+1].se.se;
			edges[i].se.se=edges[i+1].se.se=0;
			if(edges[i]!=edges[i+1]) sub2=0;
			edges[i].se.se=a1; edges[i+1].se.se=a2;
		}
	}
	else sub2=0;
	ori.Floyd();
	ll as = ori.d[0][n-1]+ori.d[n-1][0];
	sort(VV.begin(),VV.end());
	for(int i=0;i<min(100,m);i++) S.insert(VV[i].se);
	oriunw.dijkstra(0);
	for(int i=0;i<n;i++)
	{
		if(i==0) continue;
		if(oriunw.par[i]!=-1)
		{
			//cerr<<oriunw.par[i]<<' '<<i<<' '<<ma[{oriunw.par[i],i}].se<<endl;
			S.insert(ma[{oriunw.par[i],i}].se);
		}
	}
	
	oriunw.dijkstra(n-1);
	for(int i=0;i<n;i++)
	{
		if(i==n-1) continue;
		if(oriunw.par[i]!=-1)
		{
			//cerr<<oriunw.par[i]<<' '<<i<<' '<<ma[{oriunw.par[i],i}].se<<endl;
			S.insert(ma[{oriunw.par[i],i}].se);
		}
	}
	/*
	oriunw2.dijkstra(n-1);
	for(int i=0;i<n;i++)
	{
		if(i==n-1) continue;
		if(oriunw2.par[i]!=-1)
		{
			//cerr<<oriunw2.par[i]<<' '<<i<<' '<<ma[{oriunw2.par[i],i}].se<<endl;
			S.insert(ma[{oriunw2.par[i],i}].se);
		}
	}
	*/
	oriunw2.dijkstra(0);
	for(int i=0;i<n;i++)
	{
		if(i==0) continue;
		if(oriunw2.par[i]!=-1)
		{
			//cerr<<oriunw.par[i]<<' '<<i<<' '<<ma[{oriunw.par[i],i}].se<<endl;
			S.insert(ma[{oriunw2.par[i],i}].se);
		}
	}
	res=min(res,as);
	//test(ma[{141,15}].se);
	//assert(sub2);
	if(sub2)
	{
		for(auto E:edges)
		{
			int u=E.fi.fi; int v=E.fi.se; 
			ll c=E.se.fi; ll d=E.se.se;
			//should i add the edge v->u
			res=min(res,d+ori.d[0][n-1]+ori.d[n-1][v]+c+ori.d[u][0]);
			res=min(res,d+ori.d[0][v]+c+ori.d[u][n-1]+ori.d[n-1][0]);
			res=min(res,d+ori.d[0][v]+c+ori.d[u][n-1]+ori.d[n-1][v]+c+ori.d[u][0]);
			res=min(res,ori.d[0][n-1]+ori.d[n-1][0]);
		}
	}
	else
	{
		
		set<int> nw;
		for(int s:S)
		{
			int u=edges[s].fi.fi; int v=edges[s].fi.se;
			nw.insert(ma[{u,v}].se);
		}
		//cerr<<nw.size()<<endl;
		for(int s:nw) 
		{
			test(s);
		}
	}
	if(res>=ll(1e18)) res=-1;
	cout<<res<<'\n';
}

Compilation message (stderr)

ho_t4.cpp: In member function 'void Graph::bfs(int)':
ho_t4.cpp:62:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
    for(int i = 0; i < adj[u].size(); i++)
                   ~~^~~~~~~~~~~~~~~
ho_t4.cpp: In member function 'void Graph::bfs01(int)':
ho_t4.cpp:85:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
    for(int i = 0; i < adj[u].size(); i++)
                   ~~^~~~~~~~~~~~~~~
ho_t4.cpp: In member function 'void Graph::dijkstra(int, int)':
ho_t4.cpp:119:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
    for(int i = 0; i < adj[u].size(); i++)
                   ~~^~~~~~~~~~~~~~~
ho_t4.cpp: In member function 'void Graph::Floyd()':
ho_t4.cpp:144:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
    for(int j = 0; j < adj[i].size(); j++)
                   ~~^~~~~~~~~~~~~~~
ho_t4.cpp: In function 'int main()':
ho_t4.cpp:311:6: warning: variable 'all0' set but not used [-Wunused-but-set-variable]
  int all0=1;
      ^~~~

• Subtask 1: 5 / 5
• Subtask 2: 11 / 11
• Subtask 3: 21 / 21
• Subtask 4: 0 / 63