Dijkstra+二叉堆解Sweet Butter

最新推荐文章于 2023-10-29 14:10:02 发布
最新推荐文章于 2023-10-29 14:10:02 发布
阅读量1.9k 收藏 1
点赞数 1
分类专栏： USACO 文章标签： 算法 C usaco Sweet Butter
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hiboy_111/article/details/43887699
版权 
 
 
 
  
  
Sweet Butter
 
 
 

 
 

  
  Greg Galperin -- 2001
 
 
Farmer John has discovered the secret to making the sweetest butterin all of Wisconsin: sugar.  By placing a sugar cube out in thepastures, he knows the N (1 <= N <= 500) cows will lick it and thuswill produce super-sweet butter which can be marketed at betterprices.  Of course, he spends the extra money on luxuries for thecows.
FJ is a sly farmer.  Like Pavlov of old, he knows he can train thecows to go to a certain pasture when they hear a bell.  He intends toput the sugar there and then ring the bell in the middle of theafternoon so that the evening's milking produces perfect milk.
FJ knows each cow spends her time in a given pasture (not necessarilyalone).  Given the pasture location of the cows and a description ofthe paths that connect the pastures, find the pasture in which to placethe sugar cube so that the total distance walked by the cows when FJrings the bell is minimized. FJ knows the fields are connected well enoughthat some solution is always possible.
PROGRAM NAME: butter
INPUT FORMAT

 
 
  •  Line 1: Three space-separated integers: N, the number of pastures: P (2 <= P <=800), and the number of connecting paths: C (1 <= C <= 1,450).  Cowsare uniquely numbered 1..N. Pastures are uniquely numbered 1..P.
  •  Lines 2..N+1: Each line contains a single integer that is the pasture number in whicha cow is grazing.  Cow i's pasture is listed on line i+1.
  •  Lines N+2..N+C+1: Each line contains three space-separated integers that describe a singlepath that connects a pair of pastures and its length.  Paths may betraversed in either direction.  No pair of pastures is directly connectedby more than one path.  The first two integers are in the range 1..P; thethird integer is in the range (1..225).
SAMPLE INPUT (file butter.in)
3 4 5
2
3
4
1 2 1
1 3 5
2 3 7
2 4 3
3 4 5


INPUT DETAILS
This diagram shows the connections geometrically:
          P2  
 P1 @--1--@ C1
     \    |\
      \   | \
       5  7  3
        \ |   \
         \|    \ C3
       C2 @--5--@
          P3    P4

OUTPUT FORMAT

 
 
  •  Line 1: A single integer that is the minimum distance the cows must walk toa pasture with a sugar cube.
SAMPLE OUTPUT (file butter.out) 
8

OUTPUT DETAILS:

Putting the cube in pasture 4 means: cow 1 walks 3 units; cow 2 walks 5
units; cow 3 walks 0 units -- a total of 8.

分析

用邻接表存储路径，再用Dijkstra求出每个牧场作为中心的和，同时用小顶堆优化。
我终于吃到你了，香甜的黄油。
http://www.acmerblog.com/dijkstras-algorithm-adjacency-list-5882.html
 

运行结果

Executing...
   Test 1: TEST OK [0.008 secs, 3512 KB]
   Test 2: TEST OK [0.008 secs, 3512 KB]
   Test 3: TEST OK [0.003 secs, 3512 KB]
   Test 4: TEST OK [0.008 secs, 3512 KB]
   Test 5: TEST OK [0.016 secs, 3512 KB]
   Test 6: TEST OK [0.032 secs, 3512 KB]
   Test 7: TEST OK [0.068 secs, 3512 KB]
   Test 8: TEST OK [0.111 secs, 3512 KB]
   Test 9: TEST OK [0.186 secs, 3512 KB]
   Test 10: TEST OK [0.205 secs, 3512 KB]

All tests OK.


通过代码

/*
ID: c1033311
LANG: C++
TASK: butter
*/
#include<stdio.h>
#include<stdlib.h>
//#include<string.h>  //一定要注释掉才能通过编译
#define MAX 0x7FFFFFFF



/******************* 单链表中的元素 *******************/
struct Node
{
	int pp;
	int ww;
	struct Node *next; 
};



/******************* 堆中元素（小顶堆，下标从1开始）*******************/
struct{
	int p;
	int w;
}heap[801];


int sum;   //堆中元素的数量和
int index[802];  //index[i]为牧场i在堆中的下标


/******************* 初始化堆 *******************/
void init_heap(int n,int start){  //n为牧场总数，start为开始牧场，它不在堆中
	int i,j;
	for(i=1,j=1;i<=n+1;++i)
		if(i!=start)
		{
			heap[j].p=i;
			heap[j].w=MAX;
			index[i]=j;
			++j;
		}

	heap[j].p=start;
	heap[j].w=0;
	index[start]=j;

	sum=n-1;
}



/******************* 交换堆中下标为i,j的两个元素 *******************/
void exchange_heap(int i,int j)
{
	int t,dt;

	index[heap[i].p]=j;
	index[heap[j].p]=i;

	t=heap[i].p;
	dt=heap[i].w;

	heap[i].p=heap[j].p;
	heap[i].w=heap[j].w;

	heap[j].p=t;
	heap[j].w=dt;
}



/******************* 上浮 *******************/
void up_heap(int i,int dis){  //i牧场的距离减小到dis

	int n=index[i];

	while((n/2)>=1 && dis<heap[n/2].w) //上浮
	{
		heap[n].w=heap[n/2].w;	
		heap[n].p=heap[n/2].p;
		index[heap[n/2].p]=n;
		n/=2;
	}

	heap[n].w=dis; //插入
	heap[n].p=i;
	index[i]=n;
}



/******************* 下沉 *******************/
void down_heap(int i,int dis){  //i牧场的距离增大到dis

	int n=index[i];
	int m;

	while((2*n<=sum) && (dis>heap[2*n].w || dis>heap[2*n+1].w)) //下沉，堆最后有个虚拟牧场避免越界
	{
		m=heap[2*n].w<heap[2*n+1].w?2*n:2*n+1;
			
		heap[n].w=heap[m].w;	
		heap[n].p=heap[m].p;
		index[heap[m].p]=n;
		n=m;
	}

	heap[n].w=dis; //插入
	heap[n].p=i;
	index[i]=n;
}



int main(){
	FILE *fin=fopen("butter.in","r");
	FILE *fout=fopen("butter.out","w");
	
	
	int N,P,C;
	struct Node *E[801]={NULL}; //从1开始
	int min_sum=MAX,temp;  //从一点出发到其它点的和
	int cow[500];
	int i,j,a,b,c;



	fscanf(fin,"%d%d%d",&N,&P,&C);

	for(i=0;i<N;++i)
		fscanf(fin,"%d",&cow[i]);

	for(i=0;i<C;++i)  //建立单链表
	{
		fscanf(fin,"%d%d%d",&a,&b,&c);

		struct Node *node=(Node*)malloc(sizeof(Node));
		node->pp=b;
		node->ww=c;
		node->next=E[a];  //头插法
		E[a]=node;

		node=(Node*)malloc(sizeof(Node));
		node->pp=a;
		node->ww=c;
		node->next=E[b];  //头插法
		E[b]=node;
	}

	

	for(i=1;i<=P;++i) //枚举所有的牧场作为中心点
	{
		int now=i;

		init_heap(P,now);

		for(j=1;j<P;++j)  //更新牧场i到其它P-1个牧场的距离
		{
			Node *e=E[now];
			while(e!=NULL)
			{
				if(index[e->pp]<=sum && heap[index[e->pp]].w>heap[index[now]].w+e->ww)
					up_heap(e->pp,heap[index[now]].w+e->ww);

				e=e->next;
			}//end while
	

			now=heap[1].p;
			exchange_heap(1,sum);
			exchange_heap(sum,sum+1);
			--sum;  //删除当前距离最小的牧场

			down_heap(heap[1].p,heap[1].w);
		}

		temp=0;
		for(j=0;j<N;++j)
			temp+=heap[index[cow[j]]].w;
	
		
		if(temp<min_sum)
			min_sum=temp;
	}
	


	fprintf(fout,"%d\n",min_sum);

	return 0;
}

如果

不注释掉#include<string.h>的话，会出现以下情况。因为index[]和string.h中的一个函数声明冲突，真见鬼。详情请看《C专家编程》5.4警惕Interpositioning（P102）


USER: Cao xiao [c1033311]
TASK: butter
LANG: C++

Compiling...
Compile error: your program did not compile correctly:

program.c:21:10: warning: anonymous type with no linkage used to declare variable '<anonymous struct> heap [801]' with linkage [enabled by default] }heap[801];          ^
      --> 20: 	int w;
      --> 21: }heap[801];
program.c:23:14: error: 'int index [802]' redeclared as different kind of symbol int index[802];  //index[i]i              ^
      --> 22: int sum;   //¶ÑÖÐÔªËصÄÊýÁ¿ºÍ
      --> 23: int index[802];  //index[i]ΪÄÁ³¡iÔÚ¶ÑÖеÄϱê
In file included from program.c:8:0:
/usr/include/string.h:482:1: error: previous declaration of 'const char* index(const char*, int)' index (const char *__s, int __c) __THROW ^
program.c: In function 'void init_heap(int, int)':
program.c:32:11: error: invalid types '<unresolved overloaded function type>[int]' for array subscript    index[i]=j;           ^
      --> 31: 			heap[j].w=MAX;
      --> 32: 			index[i]=j;
program.c:37:13: error: invalid types '<unresolved overloaded function type>[int]' for array subscript  index[start]=j;             ^
      --> 36: 	heap[j].w=0;
      --> 37: 	index[start]=j;
program.c: In function 'void exchange_heap(int, int)':
program.c:44:17: error: invalid types '<unresolved overloaded function type>[int]' for array subscript  index[heap[i].p]=j;                 ^
      --> 43: 	int t,dt;
      --> 44: 	index[heap[i].p]=j;
program.c:45:17: error: invalid types '<unresolved overloaded function type>[int]' for array subscript  index[heap[j].p]=i;                 ^
      --> 44: 	index[heap[i].p]=j;
      --> 45: 	index[heap[j].p]=i;
program.c: In function 'void up_heap(int, int)':
program.c:55:15: error: invalid types '<unresolved overloaded function type>[int]' for array subscript  int n=index[i];               ^
      --> 54: void up_heap(int i,int dis){  //iÄÁ³¡µÄ¾àÀë¼õСµ½dis
      --> 55: 	int n=index[i];
program.c:60:20: error: invalid types '<unresolved overloaded function type>[int]' for array subscript   index[heap[n/2].p]=n;                    ^
      --> 59: 		heap[n].p=heap[n/2].p;
      --> 60: 		index[heap[n/2].p]=n;
program.c:65:9: error: invalid types '<unresolved overloaded function type>[int]' for array subscript  index[i]=n;         ^
      --> 64: 	heap[n].p=i;
      --> 65: 	index[i]=n;
program.c: In function 'void down_heap(int, int)':
program.c:69:15: error: invalid types '<unresolved overloaded function type>[int]' for array subscript  int n=index[i];               ^
      --> 68: void down_heap(int i,int dis){  //iÄÁ³¡µÄ¾àÀëÔö´óµ½dis
      --> 69: 	int n=index[i];
program.c:77:18: error: invalid types '<unresolved overloaded function type>[int]' for array subscript   index[heap[m].p]=n;                  ^
      --> 76: 		heap[n].p=heap[m].p;
      --> 77: 		index[heap[m].p]=n;
program.c:82:9: error: invalid types '<unresolved overloaded function type>[int]' for array subscript  index[i]=n;         ^
      --> 81: 	heap[n].p=i;
      --> 82: 	index[i]=n;
program.c: In function 'int main()':
program.c:121:19: error: invalid types '<unresolved overloaded function type>[int]' for array subscript     if(index[e->pp]<=sum && heap[index[e->pp]].w>heap[index[now]].w+e->ww)                   ^
      --> 120: 			{
      --> 121: 				if(index[e->pp]<=sum && heap[index[e->pp]].w>heap[index[now]].w+e->ww)
program.c:121:45: error: invalid types '<unresolved overloaded function type>[int]' for array subscript     if(index[e->pp]<=sum && heap[index[e->pp]].w>heap[index[now]].w+e->ww)                                             ^
program.c:121:64: error: invalid types '<unresolved overloaded function type>[int]' for array subscript     if(index[e->pp]<=sum && heap[index[e->pp]].w>heap[index[now]].w+e->ww)                                                                ^
program.c:122:34: error: invalid types '<unresolved overloaded function type>[int]' for array subscript      up_heap(e->pp,heap[index[now]].w+e->ww);                                  ^
      --> 121: 				if(index[e->pp]<=sum && heap[index[e->pp]].w>heap[index[now]].w+e->ww)
      --> 122: 					up_heap(e->pp,heap[index[now]].w+e->ww);
program.c:134:27: error: invalid types '<unresolved overloaded function type>[int]' for array subscript    temp+=heap[index[cow[j]]].w;                           ^
      --> 133: 		for(j=0;j<N;++j)
      --> 134: 			temp+=heap[index[cow[j]]].w;

Xiao Cao
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉堆（最小堆）+二项堆+斐波那契堆
05-19
二叉堆（最小堆）+二项堆+斐波那契堆 根基算法导论C++实现
dijkstra算法的三种实现：数组，二叉堆，斐波那契堆 + 部分实验报告
01-12
dijkstra算法的三种实现：数组，二叉堆，斐波那契堆 + 部分实验报告 dijkstra算法的三种实现：数组，二叉堆，斐波那契堆 + 部分实验报告 dijkstra算法的三种实现：数组，二叉堆，斐波那契堆 + 部分实验报告
最短路径——Dijkstra算法以及二叉堆优化（含证明）
weixin_34355715的博客
12-05 837
一般最短路径算法习惯性的分为两种：单源最短路径算法和全顶点之间最短路径。前者是计算出从一个点出发，到达所有其余可到达顶点的距离。后者是计算出图中所有点之间的路径距离。 单源最短路径 Dijkstra算法 思维 本质上是贪心的思想，声明一个数组dis来保存源点到各个顶点的最短距离和一个保存已经找到了最短路径的顶点的集合：S，原本的元素构成集合Q，初始时，原点 s 的路径权重被赋为 0 （dis[s...
invalid types ‘＜unresolved overloaded function type＞[int]‘ for array subscript|
Growzhang的博客
10-20 6133
记录一下错误error: invalid types ‘[int]’ for array subscript| 这个错误产生的原因是由于我定义数组的时候出错了先看代码吧 #include<stdio.h> int main() { int n; n=5; int a[n]; } 原因就在于像这样定义一个数组，只要一使用就会报这样的错误，当然并非报这样的错误就是由于这个原因，这只是原因之一，一般而言，我们都知道不可以这样来定义数组，但是由于写多了，写的有点懵了，犯
[Warning] anonymous type with no linkage used to declare variable with linkage
qq_60458305的博客
10-02 2295
结构体声明警告解决方法
邻接矩阵实现有向图、无向图、有向网、无向网——简单使用
wh1236666的博客
12-14 5132
邻接矩阵(AdjacencyMatrix)的存储结构就是通过一维数组存储图中顶点的信息，用矩阵表示图中各个顶点的的临界关系，而矩阵通过一个二维数组表示。 理论知识可以参考：https://blog.csdn.net/weixin_42265429/article/details/90202076 关于使用邻接矩阵去实现图和网，代码如下： #include<stdio.h> #include<string.h> #include<malloc.h> #include&l.
编写c++程序过程中出现的错误 annonymous type with no linkage used to declare variable
于沛杰的博客
11-05 1万+
问题1   annonymous type with no linkage used to declare variable 我的代码： struct{ string name; int K; string thing[10]; }stu[maxsize]; 解决方案： struct student{ string name; int K; string thing[10];
堆优化的Dijkstra算法用PYTHON实现
04-15
戴克斯特拉算法（Dijkstra’s algorithm）是由荷兰计算机科学家艾兹赫尔·戴克斯特拉提出。迪科斯彻算法使用了广度优先搜索解决非负权有向图的单源最短路径问题，算法最终得到一个最短路径树。该算法常用于路由算法...
最短路径+dijkstra+matlab代码+算法效率测试
11-05
搭配博客使用： https://blog.csdn.net/lishan132/article/details/108527271
SPFA+Dijkstra+Floyd Java模板
01-20
SPFA import java.util.Arrays; import java.util.LinkedList; import java.util.Queue; import java.util.Scanner; public class SPFA { static SE[] e = new SE[9999];... static int[] dis = new int[9999];...
几种堆(BinaryHeap, FibHeap, PairHeap)在Dijkstra算法上的效率试
05-29
几种堆(BinaryHeap, FibHeap, PairHeap)在Dijkstra算法上的效率试
【记录报错1】anonymous type with no linkage used to declar
Qvicky_的博客
10-29 446
struct后面加一个结构体类型clo就行了。在声明结构体变量时，没有定义结构体类型。
用typedef 将结构体重定义时遇到的问题
m0_54797575的博客
04-18 437
Linklist 定义L为二级指针，编译时遇到错误。我没有给结构体命名，所以无法进行声明其它的变量 L；改为 typedef struct list{
日常错误积累
cyan-blue
08-27 1097
RuntimeError Root Cause You called this URL via POST, but the URL doesn't end in a slash and you have APPEND_SLASH set. Django can't redirect to the slash URL while maintaining POST data. Change your f
codeblocks各种编译错误积累
fofu33的专栏
06-13 1万+
1. 警告： anonymous type with no linkage used to declare variable ‘ a [1001]’ with linkage [默认启用]| 我的代码： struct{ int class_num, assess; }a[size]; 似乎它不允许没有命名的结构体， 于是在struct后加了个结构体名node， 这样编译通过。
[Error] anonymous type with no linkage used to declare function ‘bool InitSLinkList
傅里叶也头大
06-30 3077
报错如下 解决如下 typedef struct SNode{ int data; int next; }SLinkList[MaxSize];
报错[Error] invalid types ‘int[int]‘ for array subscript原因及解决方案
热门推荐
被一个OIER遗弃的一堆烂代码
08-10 7万+
这通常是数组的问题，我目前总结出3种可能： 数组变量名不一致，或者没定义，比如你定义了一个ans数组，但是你在用的时候误写成了a数组（oj应该爆CE） 数组空间不够，比如你要访问a[6]，可是你只定义了int a[6]数组，所以下标最多到5，定义改成7就行了。（oj应该爆RE） 变量名和数组名重复定义，比如定义了一个int a;然后又定义了一个int a[6];数组，（oj应该爆CE吧） ...
编译错误：invalid types ‘int[int]‘ for array subscrip
TGA麻辣香锅的博客
12-05 2万+
invalid types ‘int[int]’ for array subscrip 注意：可能是数组名和常量名重复定义了 比如 int a； int a[];
dijkstra+二叉堆Python代码实现
最新发布
04-24
Dijkstra算法是一种用于解决单源最短路径问题的经典算法，而二叉堆是一种常用的数据结构，用于实现Dijkstra算法中的优先队列。下面是Dijkstra算法结合二叉堆的Python代码实现： ```python import heapq def ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值