道路重建(记忆化搜索+贪心)

道路重建(记忆化搜索+贪心)

一、题目

道路重建

时间限制: 1 Sec  内存限制: 128 MB
提交: 9  解决: 6
[提交][状态][讨论版]

题目描述

现在有一棵n个结点的树（结点从1到n编号），请问至少要删除几条边，才能得到一个恰好有p个结点的子树？

输入

第一行输入两个数n和p (1 <= n<= 150, 1 <= p<= n)

接下来输入n-1行，每行两个整数x y，表示x和y之间有一条边。

输出

输出答案。

样例输入

11 6

1 2

1 3

1 4

1 5

2 6

2 7

2 8

4 9

4 10

4 11

样例输出

 

2

提示

如果1-4 和 1-5 两条边删除，结点1, 2, 3, 6,
7, 8会形成一颗有6个结点的子树。

来源

二、分析

#include <iostream>
#include <algorithm>
using namespace std;

struct node{
    int nameNum;//nameNum表示节点的编号
    int val;//val表示节点i的所有孩子（包括直接和间接）与它本身之和
};
struct node a[155];//用a[i].val表示节点i的所有孩子（包括直接和间接）与它本身之和
bool vis[155];//vis[i]==false表示节点i没有被访问过
bool adjacencyMatrix[155][155];//adjacencyMatrix[i][j]=true表示i是j的父亲
int n,p;
int fatherSum[155];//fatherSum[i]表示congi节点出发到它的祖先，经过的节点数，也就是它和他所有祖先的和
int father[155][155];//father[i][j]记录i号节点的第j个父亲 //记忆化搜索，把所有找过的节点的父亲都记录下来

int minStep;
int choose[155];//记录所有被选的边
int ans[155];

bool operator <(node p1,node p2){
    return p1.val>p2.val;
}

void printArr();
void printArr_a();
void printArr_ans();

void readData(){
    cin>>n>>p;
    int father1,child1;
    for(int i=1;i<n;i++){
        cin>>father1>>child1;
        a[father1].nameNum=father1;
        a[child1].nameNum=child1;
        //记录直接孩子的数目
        //a[father1].val++;
        adjacencyMatrix[father1][child1]=true;
    }
}


//记忆化搜索，把所有找过的节点的父亲都记录下来
//回溯找i的所有父亲，给它的所有父亲的a[i]加1
void findFather(int child){
    if(child==1) return;
    for(int i=1;i<=n;i++){
        if(adjacencyMatrix[i][child]){
            a[i].val++;
            father[child][0]=father[i][0]+1;
            father[child][father[child][0]]=i;
            if(father[i][0]!=0){//说明i节点的父亲我已经找过了
                for(int j=1;j<=father[i][0];j++){
                    father[child][j]=father[i][j];
                    a[father[i][j]].val++;
                }
            }
            else findFather(i);
            break;
        }
    }
}

//填充数组a
void findArr_a(){
    for(int i=1;i<=n;i++){//对1-n这n个节点找父亲
        a[i].val++;
        findFather(i);
    }
}

void init(){
    readData();
    findArr_a();//回溯法找a[i]
    //printArr_a();
    //printArr();
}

//下一次搜索的时候，我肯定没有必要再从n开始搜索
//如果前minstep根都达不到长度，那么所有后面的都不用看了，所以minStep的初始值就是n
//如果这一根和上一根相同，如果上一根不可以，那么这一根也不用尝试了
void search(int m,int step,int start){
    if(m==0){
        if(step<minStep){
            minStep=step;
            for(int i=1;i<=minStep;i++){
                ans[i]=choose[i];
            }
        }

    }else
    for(int i=start;i<=n;i++){
        //如果step大于等于了minStep，它及它后面的都不用考虑了
        if(step>=minStep) return;

        //如果在choose里面有他的父亲，那他就不用考虑了
        int findFather=false;
//        for(int j=1;j<=step;j++){
//            for(int k=1;k<=father[a[i].nameNum][0];k++){
//                if(choose[j]==father[a[i].nameNum][k]){
//                    findFather=true;
//                }
//            }
//        }
        for(int j=1,k=1;j<=step&&k<=father[a[i].nameNum][0];){
            if(choose[j]==father[a[i].nameNum][k]){
                findFather=true;
                break;
            }else if(choose[j]<father[a[i].nameNum][k]){
                j++;
            }else if(choose[j]>father[a[i].nameNum][k]){
                k++;
            }
        }
        if(findFather) continue;

        //如果这一根和上一根相同，如果上一根不可以，那么这一根也不用尝试了
        if(i>1&&a[i].val==a[i-1].val&&!vis[i-1]) continue;

        //如果前minstep根都达不到长度，那么所有后面的都不用看了，所以minStep的初始值就是n
        if(minStep!=n){
            int sum=0;
            int k=minStep;
            int i1=i;
            while(k--){
                sum+=a[i1++].val;
            }
            if(sum<m) return;
        }

        if(!vis[i]&&a[i].val<=m){
            vis[i]=true;
            choose[step+1]=a[i].nameNum;
            search(m-a[i].val,step+1,i+1);
        }
        vis[i]=false;
    }
}

void findans(){
    int m=n-p;
    minStep=n;
    search(m,0,1);
    cout<<minStep<<endl;
    printArr_ans();
}

int main() {
    freopen("src/test8.txt","r",stdin);
    //freopen("src/test2.txt","r",stdin);
    //freopen("src/RoadRebuild.txt","r",stdin);
    init();
    sort(a+1,a+n+1);
    //printArr_a();
    findans();
    return 0;
}

void printArr_ans(){
    for(int i=1;i<=minStep;i++){
        cout<<ans[i]<<" ";
    }
    cout<<endl;
}

void printArr_a(){
    for(int i=1;i<=n;i++){
        cout<<a[i].val<<" "<<a[i].nameNum<<"    ";
    }
    cout<<endl;
}

void printArr(){
    cout<<"Arr a"<<endl;
    cout<<"--------------------------------------------------------------------"<<endl;
    for(int i=1;i<=n;i++){
        cout<<a[i].val<<" ";
    }
    cout<<endl;

    cout<<"Arr fatherSum"<<endl;
    cout<<"--------------------------------------------------------------------"<<endl;
    for(int i=1;i<=n;i++){
        cout<<fatherSum[i]<<" ";
    }
    cout<<endl;


    cout<<"Arr vis"<<endl;
    cout<<"--------------------------------------------------------------------"<<endl;
    for(int i=1;i<=n;i++){
        cout<<vis[i]<<" ";
    }
    cout<<endl;

    cout<<"Arr adjacencyMatrix"<<endl;
    cout<<"--------------------------------------------------------------------"<<endl;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            cout<<adjacencyMatrix[i][j]<<" ";
        }
        cout<<endl;
    }
    cout<<endl;

    cout<<"Arr father"<<endl;
    cout<<"--------------------------------------------------------------------"<<endl;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=father[i][0];j++){
            cout<<father[i][j]<<" ";
        }
        cout<<endl;
    }
    cout<<endl;

}