VK Cup 2017 - Round 3 D. Perishable Roads(最短路)

In the country of Never, there are n cities and a well-developed road system. There is exactly one bidirectional road between every pair of cities, thus, there are as many as  roads! No two roads intersect, and no road passes through intermediate cities. The art of building tunnels and bridges has been mastered by Neverians.

An independent committee has evaluated each road of Never with a positive integer called the perishability of the road. The lower the road's perishability is, the more pleasant it is to drive through this road.

It's the year of transport in Never. It has been decided to build a museum of transport in one of the cities, and to set a single signpost directing to some city (not necessarily the one with the museum) in each of the other cities. The signposts must satisfy the following important condition: if any Neverian living in a city without the museum starts travelling from that city following the directions of the signposts, then this person will eventually arrive in the city with the museum.

Neverians are incredibly positive-minded. If a Neverian travels by a route consisting of several roads, he considers the perishability of the route to be equal to the smallest perishability of all the roads in this route.

The government of Never has not yet decided where to build the museum, so they consider all n possible options. The most important is the sum of perishabilities of the routes to the museum city from all the other cities of Never, if the travelers strictly follow the directions of the signposts. The government of Never cares about their citizens, so they want to set the signposts in a way which minimizes this sum. Help them determine the minimum possible sum for all n possible options of the city where the museum can be built.

Input

The first line contains a single integer n (2 ≤ n ≤ 2000) — the number of cities in Never.

The following n - 1 lines contain the description of the road network. The i-th of these lines contains n - i integers. The j-th integer in thei-th line denotes the perishability of the road between cities i and i + j.

All road perishabilities are between 1 and 109, inclusive.

Output

For each city in order from 1 to n, output the minimum possible sum of perishabilities of the routes to this city from all the other cities of Never if the signposts are set in a way which minimizes this sum.

Examples

input

3
1 2
3

output

2
2
3

input

6
2 9 9 6 6
7 1 9 10
9 2 5
4 10
8

output

6
5
7
5
7
11

Note

The first example is explained by the picture below. From left to right, there is the initial road network and the optimal directions of the signposts in case the museum is built in city 1, 2 and 3, respectively. The museum city is represented by a blue circle, the directions of the signposts are represented by green arrows.

For instance, if the museum is built in city 3, then the signpost in city 1 must be directed to city 3, while the signpost in city 2 must be directed to city 1. Then the route from city 1 to city 3 will have perishability 2, while the route from city 2 to city 3 will have perishability 1. The sum of perishabilities of these routes is 3.

題意:給定一個n個點的帶邊權完全圖(n <= 2000),規定一棵有根生成樹的花費爲樹上每個點到根的邊權的最小值之和,問以每個點爲根的生成樹的最小花費是多少.
分析:大概可以發現每個點爲根的最優解一定是一條鏈,然後邊權最小的邊一定在最優解中,這樣我們可以先把所有邊的邊權先減去min(edg),然後我們把一個最優解的邊按照邊權排序,設權爲0的邊是第k個,那麼前k-2條邊的邊權一定是遞減的,因爲如果出現了遞增的情況那麼我們直接把這條邊去掉然後替換成一條到權值爲0的邊的一端點的邊結果一定不會更差,這樣就有一個n^3的算法,先求出任意兩點之間的最短路,根據前邊的結論第i個點爲根的答案就是min(dis[i][j] + f[j]*2),其中f[j]表示從第j個點出發的權值最小的邊的權值,這個算法通過一個特殊的操作可以優化到n^2,我們把原圖重構,添加一個虛點,剛開始虛點到每個點的距離爲2*f[j],然後對這個圖直接跑一邊最短路,最後d[i]+(n-1)*min就是每個點的答案.

#include <bits/stdc++.h>
#define N 2005
#define MOD 1000000007
#define INF 114748364700000ll
using namespace std;
typedef long long ll;
int n;
ll Min,g[N][N],f[N];
bool vis[N];
int main()
{
    memset(f,0x3f,sizeof(f));
    Min = INF;
    scanf("%d",&n);
    for(int i = 1;i <= n;i++)
     for(int j = i+1;j <= n;j++)
     {
        scanf("%I64d",&g[i][j]);
        g[j][i] = g[i][j];
        if(Min > g[i][j]) Min = g[i][j];
     }
    for(int i = 1;i <= n;i++)
     for(int j = 1;j <= n;j++)
      if(i != j)
      {
          g[i][j] -= Min;
          f[i] = min(f[i],2*g[i][j]);
      }
    for(int i = 1;i <= n;i++)
    {
        int t = 0;
        for(int j = 1;j <= n;j++)
         if(f[t] > f[j] && !vis[j]) t = j;
        vis[t] = 1;
        for(int j = 1;j <= n;j++) f[j] = min(f[j],f[t] + g[t][j]);
    }
    for(int i = 1;i <= n;i++) cout<<f[i]+(n-1ll)*Min<<endl;
}