HDOJ 2489 Minimal Ratio Tree (Kruskal+Dfs)

Minimal Ratio Tree

TimeLimit: 2000/1000 MS (Java/Others)    Memory Limit:32768/32768 K (Java/Others)
Total Submission(s): 4294    Accepted Submission(s): 1360

Problem Description

For a tree,which nodes and edges are all weighted, the ratio of it is calculated accordingto the following equation.
                                                                                                               

Given a complete graph of n nodes with all nodes and edges weighted, your taskis to find a tree, which is a sub-graph of the original graph, with m nodes andwhose ratio is the smallest among all the trees of m nodes in the graph.

 

 

Input

Input contains multiple test cases. The first line of each test case contains twointegers n (2<=n<=15) and m (2<=m<=n), which stands for the numberof nodes in the graph and the number of nodes in the minimal ratio tree. Twozeros end the input. The next line contains n numbers which stand for theweight of each node. The following n lines contain a diagonally symmetrical n×nconnectivity matrix with each element shows the weight of the edge connectingone node with another. Of course, the diagonal will be all 0, since there is noedge connecting a node with itself.



All the weights of both nodes and edges (except for the ones on the diagonal ofthe matrix) are integers and in the range of [1, 100].

The figure below illustrates the first test case in sample input. Node 1 andNode 3 form the minimal ratio tree.

                                                                                                     

 

 

Output

For each test case output one line contains a sequence of the m nodes whichconstructs the minimal ratio tree. Nodes should be arranged in ascending order.If there are several such sequences, pick the one which has the smallest nodenumber; if there's a tie, look at the second smallest node number, etc. Pleasenote that the nodes are numbered from 1 .

 

 

Sample Input

3 2

30 20 10

0 6 2

6 0 3

2 3 0

2 2

1 1

0 2

2 0

0 0

 

 

Sample Output

1 3

1 2

瞎扯：最近接触最小生成树后（其实后来发现跟以前的并查集差不多。。。），发现题目千变万化，但全都是套模板（最近为了让自己打代码更熟练，摒弃了以前的恶习：模板题直接复制模板，转而全部自己重新默打，感觉虽然会多花些时间，但会对算法更加熟悉，慢慢养成好习惯），今天终于遇到了一道有些变化的题目。

题意：给出一系列点和边，每个边和点都有一个权值，给定一个值m，选择一系列边，使这些边把任意m个点连接起来，使边的权值和与点的权值和最小。

分析：假设我们已经选定m个点，那么点的权值就已经固定，那么我们需要做的便是使边的权值最小，易知就是求最小生成树。至于如何选定m个点，我们可以观察到点的个数最大不会超过15，所以可以用DFS爆搜，但如果DFS每一层都遍历n个点，还是会超时的，所以我们的优化方法是按照顺序搜，每一层只判断当前点选与不选，那么每一层就变成只需要遍历两个状态。

#include <bits/stdc++.h>
using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define f(i,a,b) for(int i=(a);i<(b);++i)
typedef long long ll;
const int maxn= 20;
const int mod = 475;
const ll INF = 0x3f3f3f3f;
const double eps = 1e-6;
#define rush() int T;scanf("%d",&T);while(T--)
int pre[maxn];
int d[maxn];
int vis[maxn];
int mp[maxn][maxn];
int output[maxn];
int n,m,cnt;
double Min;


struct node
{
    int x,y,w;
}a[maxn*maxn];

bool cmp(const node &a,const node &b)
{
    return a.w<b.w;
}
void init()
{
    for(int i=0;i<=n;i++)
        pre[i]=i;
}

int find(int x)
{
    int t,r=x;
    while(x!=pre[x])
    {
        x=pre[x];
    }
    while(r!=x)
    {
        t=pre[r];
        pre[r]=x;
        r=t;
    }
    return x;
}

void join(int a,int b)
{
    int A,B;
    A=find(a);
    B=find(b);
    if(A!=B)
        pre[B]=A;
}

void solve(int sum2)
{
    int sum1=0;
    int tot=0;
    cnt=0;
    init();
    for(int i=1;i<=n;i++)
    {
        if(vis[i]==1)
        {
            for(int j=i+1;j<=n;j++)   //优化1，：避免放入性质相同的边
            {
                if(vis[j]==1)
                {
                    a[cnt].x=i;
                    a[cnt].y=j;
                    a[cnt++].w=mp[i][j];
                }
            }
        }
    }
    sort(a,a+cnt,cmp);
    for(int i=0;i<cnt;i++)
    {
        if(find(a[i].x)!=find(a[i].y))
        {
            join(a[i].x,a[i].y);
            sum1+=a[i].w;
            tot++; 
        }
        if(tot==m-1)                 //优化2：当已经找够覆盖m个点的m-1条边时，提前结束
            break;
    }
    double ans=sum1*1.0/sum2;
    tot=0;
    if(ans<Min||Min==-1)
    {
        Min=ans;
        for(int i=1;i<=n;i++)
        {
            if(vis[i]==1)
            {
                output[tot++]=i;
            }
        }
    }
}

void dfs(int num,int now,int sum2)  //num是已选择的点数，nows是当前决定是否选择的那个点的ID，sum2记录点的权值和
{
    if(now>n+1)                     //这里不是now>n,导致找了很久bug，自行理解原因
        return;
    if(num==m)
    {
        solve(sum2);
        return;
    }
    vis[now]=1;
    dfs(num+1,now+1,sum2+d[now]);
    vis[now]=0;
    dfs(num,now+1,sum2);
}
int main()
{
    while(~scanf("%d%d",&n,&m)&&(n||m))
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&d[i]);
        }
        for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
        {
            scanf("%d",&mp[i][j]);
        }
        mst(vis,0);
        Min=-1;
        dfs(0,1,0);
        for(int i=0;i<m-1;i++)
        {
            printf("%d ",output[i]);
        }
        printf("%d\n",output[m-1]);
    }
    return 0;
}