POJ-3159（差分约束+Dijikstra算法+Vector优化+向前星优化+java快速输入输出）

Candies

POJ-3159

这里是图论的一个应用，也就是差分约束。通过差分约束变换出一个图，再使用Dijikstra算法的链表优化形式而不是vector形式（否则超时）。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include<queue>
using namespace std;
const int INF=0x3f3f3f3f;
int n,m;
struct edge{
    int to;
    int cost;
    int next;
};
struct node{
    int dis;
    int to;
    node(){}
    node(int a,int b):dis(a),to(b){}
    bool operator<(const node& t)const{
        return dis>t.dis;
    }
};
edge ma[150005];
int head[30004];
int top;//指向头结点
int d[30004];
void addedge(int a,int b,int c){
    ma[top].to=b;
    ma[top].cost=c;
    ma[top].next=head[a];
    head[a]=top;
    top++;
}
void dijikstra(int s){
    priority_queue<node> que;
    for(int i=1;i<=n;i++){
        d[i]=INF;
    }
    d[s]=0;
    que.push(node(0,s));
    while(!que.empty()){
        node temp=que.top();
        que.pop();
        int v=temp.to;
        if(d[v]<temp.dis)
            continue;
        for(int h=head[v];h!=-1;h=ma[h].next){
            edge e=ma[h];
            if(d[e.to]>d[v]+e.cost){
                d[e.to]=d[v]+e.cost;
                que.push(node(d[e.to],e.to));
            }
        }
    }
}
int main(){
    memset(head,-1,sizeof(head));
    top=0;
    scanf("%d%d",&n,&m);
    int a,b,c;
    for(int i=0;i<m;i++){
        scanf("%d%d%d",&a,&b,&c);
        addedge(a,b,c);
    }
    dijikstra(1);
    cout<<d[n]<<endl;
    //system("pause");
    return 0;
}

java:PriorityQueue+Vector

package POJ;
import java.io.*;
import java.util.*;
import java.util.Vector;
public class POJ_3159 {
	static final int INF=0x3f3f3f3f;
	static int n,m;
	static class edge{
	    int to;
	    int cost;
	    edge(){}
	    edge(int a,int b){to=a;cost=b;}
	};
	static class node implements Comparable<node>{
	    int dis;
	    int to;
	    node(){}
	    node(int a,int b){dis=a;to=b;}
	    @Override
		public int compareTo(node b) {
			// TODO Auto-generated method stub
			if(dis>b.dis)
				return 1;
			else if(dis==b.dis)
				return 0;
			else return -1;
		}
	};
	static Vector<edge> []G;//[30004];
	static int []d;//[30004];
	static void dijkstra(int s){
	    PriorityQueue<node> que=new PriorityQueue<node>();
	    for(int i=1;i<=n;i++){
	        d[i]=INF;
	    }
	    d[s]=0;
	    que.add(new node(0,s));
	    while(!que.isEmpty()){
	        node temp=que.poll();
	        int v=temp.to;
	        if(d[v]<temp.dis)
	            continue;
	        for(int i=0;i<G[v].size();i++){
	            edge e=G[v].elementAt(i);
	            if(d[e.to]>d[v]+e.cost){
	                d[e.to]=d[v]+e.cost;
	                que.add(new node(d[e.to],e.to));
	            }
	        }
	    }
	}

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		Scanner cin=new Scanner(System.in);
		StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		in.nextToken();
		n=(int)in.nval;//cin.nextInt();
		in.nextToken();
		m=(int)in.nval;//cin.nextInt();
		G=new Vector[n+1];
		d=new int[n+1];
		for(int i=0;i<=n;i++)
			G[i]=new Vector<edge>();
		for(int i=0;i<m;i++) {
			in.nextToken();
			int a=(int)in.nval;//cin.nextInt();
			in.nextToken();
			int b=(int)in.nval;//cin.nextInt();
			in.nextToken();
			int c=(int)in.nval;//cin.nextInt();
			G[a].add(new edge(b,c));
		}
		dijkstra(1);
		System.out.println(d[n]);
	}

}

java:PriorityQueue+向前星

package POJ;
import java.io.*;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;
public class POJ_3159_2 {
	static int t,n,m;//1 <= n,m <= 1000000
	static final int INF=0X3F3F3F3F;
	static class edge{
		public int to,cost,next;
		edge(){}
		edge(int to,int cost,int next){
			this.to=to;
			this.cost=cost;
			this.next=next;
		}
	};
	static edge []es;

	static int []head;

	static int top;

	static int []d;
	static class node implements Comparable<node>{
		public int dis,to;
		node(){}
		node(int a,int b){
			this.dis=a;
			this.to=b;
		}
		//小根堆实现，越小的元素优先级越高
		@Override
		public int compareTo(node b) {
			// TODO Auto-generated method stub
			if(dis>b.dis)
				return 1;
			else if(dis==b.dis)
				return 0;
			else return -1;
		}

	};
	static void addedge(int a,int b,int c){
		es[top]=new edge(b,c,head[a]);
	    head[a]=top;
	    top++;

	}

	static void dijkstra(int s) {
		PriorityQueue<node>que=new PriorityQueue<node>();
		for(int i=1;i<=n;i++){
	        d[i]=INF;
	    }
	    d[s]=0;
	    que.add(new node(0,s));
	    while(!que.isEmpty()){
	        node temp=que.poll();
	        int v=temp.to;
	        if(d[v]<temp.dis)
	            continue;
        	for(int h=head[v];h!=-1;h=es[h].next){
	            edge e=es[h];
	            if(d[e.to]>d[v]+e.cost){
	                d[e.to]=d[v]+e.cost;
	                que.add(new node(d[e.to],e.to));
	            }
	        }
	    }
	}
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		Scanner cin=new Scanner(System.in);
		StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		top=0;
		in.nextToken();
		n=(int)in.nval;//cin.nextInt();
		in.nextToken();
		m=(int)in.nval;//cin.nextInt();
		es=new edge[m];
		head=new int[n+1];
		Arrays.fill(head, -1);
		d=new int[n+1];
		for(int i=0;i<m;i++) {
			int from,to,price;
			in.nextToken();
			from=(int)in.nval;//cin.nextInt();
			in.nextToken();
			to=(int)in.nval;//cin.nextInt();
			in.nextToken();
			price=(int)in.nval;//cin.nextInt();
			addedge(from,to,price);
		}

		dijkstra(1);
        System.out.println(d[n]);

	}

}