简洁起见，我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。

　　我们用数组d记录每个结点的最短路径估计值，而且用邻接表来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。

----------------

我实现的spfa 算法也是来自上面，但是速度有点慢，是在check  v是否在队列中，之前没有用hash，后来用hash就快了，但是还是卡在第九个测试样例上。 最后改成临接表的形式 ， 0.1s 刷过

//int graph[N][N];

//pair 第一个是点 ，第二个是边的权值
vector< vector < pair<int ,int > > > graph; 临接表 。。。。

大概的题意是： 给定一个序列 1 。。N ，假设全集为U那么存在多少种情况 ： 两个子集A B其中A∩B=∅ ，A∪B=U ，A元素的和== B元素的和。

开始写了个递归，枚举，提交超时：void work(int deep,int start)

和之前的clock 很像，标记状态hash 判重，遍历所有的情况就可以。

满足 a1 + a2 + …aK >= 0 (k = 1 2 … 2n ) 这个的条件的个数 为

证明：令An 为其中可以接受的系列Bn 为不可接受的系列

那么 An + Bn = .An 是我们要求的，我们可以通过求出Bn来得到An 。

我们假设存在 一个最小的K 使得a1 + a2 +…+ak 为负，那么 可以肯定 a1+…+ak-1 = 0,且ak = -1.k 为奇整数。

对于每一种不符合条件的序列a1 + a2 +…+ak +…+a2n 将a1 a2 ak 都用-a1 –a2 –ak 代替，那么新的数列

a1’ a2’ … a2n’ 就有 n+1 个 +1 和 n-1 个 –1  。即每一种 不符合条件的 数列经过上述过程都将变为

  n+1 个 +1 和 n-1 个 –1   的排列 。那么现在要证明 n+1 个 +1 和 n-1 个 –1   的排列数 == Bn

n+1 个 +1 和 n-1 个 –1   的排列 肯定存在一个 最小的k 使得 a1 + a2 + …aK <  0   而将这部分也用-a1 –a2 –ak 代替 ，也就成为了 n个1 和n个-1 构成的2n项 a1,a2….a2n   而Bn的排列就好求了

==》 

应用： 有2n个人要去剧场，入场5角，有n个人有1元，n个人有5角，剧场的卖票处刚开始没有零钱，那么存在多少种队列方式。

粗体的证明 ，我感觉有些牵强，呵呵 大家有好的方法，请指正。

我独立博客地址 http://www.fuxiang90.me/?p=286

1 在数据量不大的情况下，排序

2 维护一个最小k 的数组 ，复杂度 为 o(k * N)

3 为一个最小K个数的最大堆 o(log2 k * N)

/*
查找最小的k 个元素
题目：输入n 个整数，输出其中最小的k 个。
例如输入1，2，3，4，5，6，7和8这8个数字，
则最小的4个数字为1，2，3和4。
*/

/*
思路 ： 来一个数据处理一个 ，当来的数据量小于K 时 ，全部处理成最大堆，
        然后之后来的，必须要小于最大堆的的最大值，才可以入堆，此时 只需更新 根节点，再调整堆。

*/
# include<stdio.h>
# include<stdlib.h>
const int K = 5 ;//这里可以修改 
const int MAXN = 1000;

int max_heap[K+1] ;//维护一个 最大堆 
int end ,maxPos;


void swap(int &a ,int &b)
{
    int t = a;a = b ; b = t;
}


int FindMax()
{
    int maxPos = 1;
    for(int i = 2 ;i <= K ; i ++)
        if(max_heap[i] >max_heap[maxPos] )
            maxPos = i;
    return maxPos;
}
/*将数据插入到 数组中  插入排序的思想*/
void insertMinHeap(int mdata)
{
    int i,child = 0;
    if(end == K +1 ) // 如果堆满  
    {    
    /*    int mmaxPos = FindMax();*/
        if(mdata >= max_heap[1] ) // 如果大于等于该堆的最大值 不做任何改变
            return ;

        max_heap[1] = mdata;
        for(i = 1 ; i*2  <=  K ;i = child)
        {
            child = 2*i  ;
            if((i*2 +1 <= K && max_heap[i*2] < max_heap[i*2+1]) )//返回最大孩子的下表
                child ++;
            if(max_heap[i] < max_heap[child])
                swap(max_heap[i] ,max_heap[child]);
            else 
            {
                break;
            }
        }        
        return ;
    }

    max_heap[end ++] = mdata;
    for(i = end -1  ; i > 1 ; i /=2)
    {
        if(max_heap[i] > max_heap[i/2])
            swap(max_heap[i] ,max_heap[i/2]);
        else 
        {
            break;
        }
    }
    
}
int main()
{
    int n,data;
    freopen("in.txt","r",stdin);//如果想从文件输入 将这句注释掉 1234 1 2 3 4 5 6 7 8 9 10 11  
    end = 1;
    while(scanf("%d",&data)!=EOF) // 如果是手工输入 结束输入 按 ctrl + z
    {
        insertMinHeap(data);

    }
    
    for(int i = 1 ; i <= K ; i ++) // 
        printf("%d ",max_heap[i]);
    printf("\n");

    return 0;
}

这次写代码基本也是一气呵成　，当然中间还是调试了才正确运行　，可以通过北邮ＯＪ　的测试　，其逻辑和在图书馆写在草稿的逻辑没有多大改动，看来写代码之前

做初步分析还是很重要的　，　

http://acm.scs.bupt.cn/onlinejudge/showproblem.php?problem_id=1817　

# include<stdio.h>
# include<stdlib.h>
# include<string.h>

const int N = 2*1000+ 3 ;

# define GetMax(a,b) ((a)>(b) ?(a) :(b) )
struct TreeNode
{
	int data;
	int left,right,father;
	int deep;
};

struct TreeNode ArrayTree[N];
int used[N];

int cmp(const void * a,const void * b)
{
	return ((struct TreeNode * )a)->data - ((struct TreeNode * )b)->data;
}
void init()
{
	memset(ArrayTree,0,sizeof(ArrayTree));
	memset(used,0,sizeof(used));
	for(int i = 0 ; i < N; i ++)
	{
		ArrayTree[i].deep = 1;
		ArrayTree[i].left = -1;
		ArrayTree[i].right = -1;
	}

}

/* 
用一维数组模拟树的建立  前面end 是排好序的节点 ，也就是之后建好树的叶子节点
以 0 -end -1 和 end - end2 -1  ,后面是编码过程中形成的节点
我认为 最小的节点值  是来自两段数组中 未使用的最前面的节点中最小的 


*/
int GetMinTreeNode(int end ,int end2) // 这里还可以优化 
{
	int i = 0,min1 = 0 ,min2 =end - 1,min;
	for(i = 0 ; i < end2 ; i ++) 
	{
		if(used[i] == 0)
		{
			min1 = i ;
			break;
		}
	}
	for(i = end ; i < end2 ; i ++)
	{
		if(used[i] == 0)
		{
			min2 = i ;
			break;
		}
	}
	//min = min1 < min2 ?min1 :min2;
	//if
	if(ArrayTree[min1].data < ArrayTree[min2].data)
		min = min1;
	else 
		min = min2;
	used[min] = 1;
	return min;

}
void updataTreeNode(int father ,int deep)
{
	int left = ArrayTree[father].left;
	int right = ArrayTree[father].right;
	if(father >= 2)
	{
		if(left != -1)
		{
			ArrayTree[left].deep = deep -1;
			updataTreeNode(left,deep-1);
		}
		if( right != 1 )
		{
			ArrayTree[right].deep = deep -1;
			updataTreeNode(right,deep-1);

		}

	}
}

/* 
用一维数组模拟树的建立 
先排序 后根据哈弗曼算法 开始 建立树 这里我根节点deep 有最大值 ，然后子节点一次递减 

*/
void Hafuman( int end )
{
	qsort(ArrayTree,end,sizeof(struct TreeNode),cmp);
	
	int i,mend = end;
	struct TreeNode tNode;
	for( i = 0 ; i < end -1; i ++)
	{
		tNode.left = GetMinTreeNode(end,end + i) ;
		tNode.right = GetMinTreeNode(end,end + i);
		ArrayTree[tNode.left].father = ArrayTree[tNode.right].father = end + i;
		tNode.data = 	ArrayTree[tNode.left].data  + ArrayTree[tNode.right].data;
		tNode.deep = GetMax(ArrayTree[tNode.left].deep ,ArrayTree[tNode.right].deep ) + 1;
	//	updataTreeNode(end + i,	tNode.deep);//更新其子节点的深度值  这是一个bug 
		ArrayTree[end + i] = tNode;

		updataTreeNode(end + i,	tNode.deep);//更新其子节点的深度值 
		
	}
}
long GetHufuman(int end,int TreeDeep )
{
	int i,result = 0;
	for(i = 0 ; i < end ; i ++)
	{
		result += (TreeDeep - ArrayTree[i].deep )*ArrayTree[i].data;
	}
	return result;
}

int main()
{
	int end,i;
//	freopen("in.txt","r",stdin);
	scanf("%d",&end);
	
	init();
	for(i = 0 ; i < end ; i ++)
		scanf("%d",&ArrayTree[i].data);

	Hafuman(end);
	printf("%d\n",GetHufuman(end,ArrayTree[2*end-2].deep));
	
	
}

Reverse and Add

Input

Output

Sample Input

3
195
265
750

Sample Output

4 9339
5 45254
3 6666