[POJ 1639] Picnic Planning

[题目链接]

http://poj.org/problem?id=1639

[算法]

首先，我们可以用深度优先遍历求出1号节点去除后有几个联通块

设共有T个联通块，若T > K则无解，否则 ：

求出这些联通块的最小生成树，得到一棵最小T度生成树，我们尝试改动(K - T)条边，使得答案变得更小，具体过程如下 :

枚举所有与1相连的边，若这条边不在当前的生成树中，我们用广度优先搜索求出生成树上1号节点到该条边的节点中最长的边，用这条边的权值减去枚举边的权值即为生成树权值和变小了多少，求出这个变小的最大值

如果这个最大值大于0，将这个最大值对应的边从生成树中删除，并加入新的边，否则退出

重复以上过程(K - T)次，即可

[代码]

#include <algorithm>
#include <bitset>
#include <cctype>
#include <cerrno>
#include <clocale>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <limits>
#include <list>
#include <map>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <utility>
#include <vector>
#include <cwchar>
#include <cwctype>
#include <stack>
#include <limits.h>
using namespace std;
#define MAXN 1010
struct Edge
{
        int u,v,w;
} e[MAXN],edge[MAXN][MAXN];
int i,j,n,w,k,tot,block,ans,mx;
int val[MAXN],size[MAXN],fa[MAXN],p[MAXN],belong[MAXN];
bool visited[MAXN],flag[MAXN];
int mst[MAXN][MAXN];
map<string,int> mp;
string u,v;
vector< int > a[MAXN];
pair<int,int> ps,new_e,tmp;

inline bool cmp(Edge a,Edge b)
{
        return a.w < b.w;
}
inline int get_root(int x)
{
        if (fa[x] == x) return x;
        return fa[x] = get_root(fa[x]);
}
inline void dfs(int u)
{
        int i,v;
        visited[u] = true;
        belong[u] = block;
        for (i = ; i < a[u].size(); i++)
        {
                v = a[u][i];
                if (e[v].u == u && e[v].v !=  && !flag[v])
                {
                        flag[v] = true;
                        edge[block][++size[block]] = e[v];
                        dfs(e[v].v);
                } else if (e[v].v == u && e[v].u !=  && !flag[v])
                {
                        flag[v] = true;
                        edge[block][++size[block]] = e[v];
                        dfs(e[v].u);
                }
        }
}
inline void kruskal(int id)
{
        int i,su,sv;
        static int s[MAXN];
        for (i = ; i <= n; i++) fa[i] = i;
        sort(edge[id] + ,edge[id] + size[id] + ,cmp);
        for (i = ; i <= size[id]; i++)
        {
                su = get_root(edge[id][i].u);
                sv = get_root(edge[id][i].v);
                if (su != sv)
                {
                        ans += edge[id][i].w;
                        mst[edge[id][i].u][edge[id][i].v] = edge[id][i].w;
                        mst[edge[id][i].v][edge[id][i].u] = edge[id][i].w;
                        fa[su] = sv;
                }
        }
}
inline pair<int,int> bfs(int s)
{
        int i,cur,l,r,now,mx;
        static bool visited[MAXN];
        static pair<int,int> q[MAXN];
        static int pre[MAXN];
        bool found = false;
        pair<int,int> res;
        memset(visited,false,sizeof(visited));
        q[l = r = ] = make_pair(s,);
        visited[s] = true;
        pre[] = -;
        while (l <= r)
        {
                cur = q[l].first;
                for (i = ; i <= n; i++)
                {
                        if (visited[i]) continue;
                        if (!mst[cur][i]) continue;
                        visited[i] = true;
                        q[++r] = make_pair(i,mst[cur][i]);
                        pre[r] = l;
                        if (i == )
                        {
                                found = true;
                                break;
                        }
                }
                if (found) break;
                l++;
        }
        if (!found) return make_pair(,);
        now = r; mx = ;
        while (pre[now] != -)
        {
                if (q[now].second > mx)
                {
                        mx = q[now].second;
                        res = make_pair(q[pre[now]].first,q[now].first);
                }
                now = pre[now];
        }
        return res;
}
int main()
{
        
　　　　 cin.tie(0);
        cin >> n;
        mp["Park"] = ;
        tot = ;
        for (i = ; i <= n; i++)
        {
                cin >> u >> v >> w;
                if (!mp[u]) mp[u] = ++tot;
                if (!mp[v]) mp[v]    = ++tot;
                e[i] = (Edge){mp[u],mp[v],w};
                a[mp[u]].push_back(i);
                a[mp[v]].push_back(i);
        }
         scanf("%d",&k);
         visited[] = true;
         for (i = ; i <= n; i++)
         {
                 if (e[i].u ==  && !visited[e[i].v])
                 {
                         block++;
                        dfs(e[i].v);
                }
                if (e[i].v ==  && !visited[e[i].u])
                {
                        block++;
                        dfs(e[i].u);
                }
        }
        if (block > k)
        {
                printf("-1\n");
                return ;
        }
        for (i = ; i <= block; i++) kruskal(i);
        memset(val,0x3f,sizeof(val));
        for (i = ; i <= n; i++)
        {
                if (e[i].u ==  && e[i].w < val[belong[e[i].v]])
                {
                        val[belong[e[i].v]] = e[i].w;
                        p[belong[e[i].v]] = e[i].v;
                } else if (e[i].v ==  && e[i].w < val[belong[e[i].u]])
                {
                        val[belong[e[i].u]] = e[i].w;
                        p[belong[e[i].u]] = e[i].u;
                }
        }
        for (i = ; i <= block; i++)
        {
                ans += val[i];
                mst[][p[i]] = val[i];
                mst[p[i]][] = val[i];
        }
        for (i = ; i <= k - block; i++)
        {
                mx = ;
                ps = new_e = make_pair(,);
                for (j = ; j <= n; j++)
                {
                        if (e[j].u ==  && !mst[][e[j].v])
                        {
                                tmp = bfs(e[j].v);
                                if (mst[tmp.first][tmp.second] - e[j].w > mx)
                                {
                                        ps = tmp;
                                        new_e = make_pair(e[j].v,e[j].w);
                                        mx = mst[tmp.first][tmp.second] - e[j].w;
                                }
                        }
                        if (e[j].v ==  && !mst[][e[j].u])
                        {
                                tmp = bfs(e[j].u);
                                if (mst[tmp.first][tmp.second] - e[j].w > mx)
                                {
                                        ps = tmp;
                                        new_e = make_pair(e[j].u,e[j].w);
                                        mx = mst[tmp.first][tmp.second] - e[j].w;
                                }
                        }
                }
                if (mx == ) break;
                ans -= mx;
                mst[][new_e.first] = new_e.second;
                mst[ps.first][ps.second] = ;
        }
        printf("Total miles driven: %d\n",ans);

        return ;

}