Poj1062 昂贵的聘礼 （dijkstra算法）

一、Description

年轻的探险家来到了一个印第安部落里。在那里他和酋长的女儿相爱了，于是便向酋长去求亲。酋长要他用10000个金币作为聘礼才答应把女儿嫁给他。探险家拿不出这么多金币，便请求酋长降低要求。酋长说："嗯，如果你能够替我弄到大祭司的皮袄，我可以只要8000金币。如果你能够弄来他的水晶球，那么只要5000金币就行了。"探险家就跑到大祭司那里，向他要求皮袄或水晶球，大祭司要他用金币来换，或者替他弄来其他的东西，他可以降低价格。探险家于是又跑到其他地方，其他人也提出了类似的要求，或者直接用金币换，或者找到其他东西就可以降低价格。不过探险家没必要用多样东西去换一样东西，因为不会得到更低的价格。探险家现在很需要你的帮忙，让他用最少的金币娶到自己的心上人。另外他要告诉你的是，在这个部落里，等级观念十分森严。地位差距超过一定限制的两个人之间不会进行任何形式的直接接触，包括交易。他是一个外来人，所以可以不受这些限制。但是如果他和某个地位较低的人进行了交易，地位较高的的人不会再和他交易，他们认为这样等于是间接接触，反过来也一样。因此你需要在考虑所有的情况以后给他提供一个最好的方案。
为了方便起见，我们把所有的物品从1开始进行编号，酋长的允诺也看作一个物品，并且编号总是1。每个物品都有对应的价格P，主人的地位等级L，以及一系列的替代品Ti和该替代品所对应的"优惠"Vi。如果两人地位等级差距超过了M，就不能"间接交易"。你必须根据这些数据来计算出探险家最少需要多少金币才能娶到酋长的女儿。

Input

输入第一行是两个整数M，N（1 <= N <= 100），依次表示地位等级差距限制和物品的总数。接下来按照编号从小到大依次给出了N个物品的描述。每个物品的描述开头是三个非负整数P、L、X（X < N），依次表示该物品的价格、主人的地位等级和替代品总数。接下来X行每行包括两个整数T和V，分别表示替代品的编号和"优惠价格"。

Output

输出最少需要的金币数
二、题解
       这题做了两天，又是一次痛苦的经历。在处理输入的时候花了点时间，然后想到用floyd计算节点对的最短路径来解决问题。很快完成了程序的编写，于是一步步用例子测试。几乎每个例子都能找到一个错误，比如对于全0的情况，只要输出酋长的价格就行了，还有就是没有注意只要和地位低的人交易后不能和地位高的交易，但是题目说他们认为这样等于是间接接触，反过来也一样。关于这点我还是认为有点歧义。结果我写的floyd算法在这点上就是过不去，于是该用迪杰斯特拉单元最短路径计算，并且每次选出一个人先算出看其他人是否能和他交易，如此进行M次，最后再找出最短路径。
三、java代码

import java.util.*; 
public class Main {
	
   public static int[][] e; 
   public static int[]  dis; 
   public static int[] used; 
   public static int[] level; 
   public static int n,m;
   
   public static void main(String[] args){ 
    Scanner cin = new Scanner(System.in); 
    int  x,t; 
    e = new int[101][101]; 
    dis = new int[101]; 
    used =  new int[101]; 
    level = new int[101]; 
          m=cin.nextInt(); 
          n=cin.nextInt(); 
           for(int i=1;i<=n;i++){   
        	   e[0][i]=cin.nextInt(); 
               level[i]=cin.nextInt(); 
                 x=cin.nextInt(); 
                for(int j=0;j< x;j++){ 
                  t=cin.nextInt(); 
                  e[t][i]=cin.nextInt(); 
                } 
           } 
           solve(); 
} 

public static void solve(){ 
  int max,result; 
     result=e[0][1]; 
  for(int i=1;i<=n;i++){ 
	   max=level[i]; 
       for(int j=1;j<=n;j++){ 
		    if(level[j]>max || level[j]< max-m)
		    	used[j]=1;
		    else 
		    	used[j]=0;
       }
       dijkstra(); 
       if(result>dis[1])
          result=dis[1]; 
  	} 
  	System.out.println(result); 
} 
public static void dijkstra() { 
  int min,k; 
  for(int i=1;i<=n;i++){
	  dis[i]=e[0][i];
  }  
  for(int i=1;i<=n;i++) { 
	   min=Integer.MAX_VALUE; 
       k=0; 
       for(int j=1;j<=n;j++){ 
         if(used[j]==0 && dis[j]< min){
        	 min=dis[j]; 
              k=j; 
          } 
       }
       if(k==0) 
           break; 
       used[k]=1; 
       for(int j=1;j<=n;j++){
          if(used[j]==0 && e[k][j]>0 && min+e[k][j]< dis[j]){ 
        	  dis[j]=min+e[k][j];
       }
       }
    } 
  } 
} 

floyd()，望高手指教。

import java.util.Scanner;

class Node{
	int price;
    int level;
	public Node(int p,int l){
		price=p;
		level=l;
	}
}

public class Main {
    static int size;
    static int m;
	static int[][] map;
	static Node[] node;
	static int[] re;
	static boolean visit[];
	static int INF=Integer.MAX_VALUE;
	public static void floyd(){
		  int i=1,j,k;
	      for(k=1;k<=size;k++){
	             for(j=1;j<=size;j++){
	            	  if(i!=j && map[i][k]!=INF && map[k][j]!=INF && map[i][k] + map[k][j] < map[i][j]){
	            		  re[j]=map[i][k] + map[k][j];
            			  map[i][j] = map[i][k] + map[k][j];
            			  visit[j]=true;
	            	  }
	              }
	       }
	}
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		int i,j,k,t1,t2;
		m=sc.nextInt();
		size=sc.nextInt();
		map=new int[size+1][size+1];
		node=new Node[size+1];
		visit=new boolean[size+1];
		for(i=0;i<=size;i++){
			for(j=0;j<=size;j++){
				map[i][j]= (i==j)? 0:INF;
			}
		}
		for(i=1;i<=size;i++){
			node[i]=new Node(sc.nextInt(),sc.nextInt());
			k=sc.nextInt();
			for(j=0;j<k;j++){
				t1=sc.nextInt();
				t2=sc.nextInt();
				map[i][t1]=t2;
			}
		}
		
		for(i=1;i<=size;i++){
			for(j=1;j<=size;j++){
				if(i!=j && map[i][j]!=INF&& Math.abs(node[i].level-node[j].level)>m){
					map[i][j]=INF;
				}
			}
		}
		floyd();
		for(i=2;i<=size;i++){
			if( map[1][i]!=INF)
				map[1][i]+=node[i].price;
		}
		
		int min=INF;
		for(i=1;i<=size;i++){
			if(map[1][i]<min)
				min=map[1][i];
		}
		System.out.println(min);
	}
}

版权声明：本文为博主原创文章，未经博主允许不得转载。

转载于:https://www.cnblogs.com/AndyDai/p/4734148.html