hust1350Trie【字典树+dfs || 字典树 + LCA】

大意：告诉你一些字符串 让你组成字典树，

 

然后定义每个节点到所有叶子节点的距离的和等于改点的value

当根节点只有一个孩子，该根节点也算一个叶子节点

问所有节点的value的最小值

 

分析：

开始做的时候  就想的是   枚举每个点  然后求它到所有叶子节点的和  求任意两点的最近距离  用公共祖先来求 

于是就有了这个算法

需要预处理出来所有的叶子节点  

不能单纯的用字典树的flag来记录  例如插入aaa aa a  那么 a  aa aaa 都会被当成叶子节点  

对于这里的处理 我是排了一次序  把节点的最后值用flag标记

然后就是判断根节点是否只有一个孩子 

如果只有孩子  那么就加入孩子节点的数组

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<vector>
#include <set>
using namespace std;

const int MAXN = 100010;
const int PP = 30;
const int maxn = MAXN;


int tire[maxn][30];
int flag[maxn];
int ceng[maxn];

class LCA_RMQ
{
public:
    int n;
    int pow2[PP]; 
    int tim;
    int first[MAXN]; 
    int nodeId[MAXN*2]; 
    int dep[MAXN*2]; 
    int dp[MAXN*2][PP]; 
    bool vis[MAXN]; 
    vector<int> edge[MAXN];

    void init(int n)
    {
        for(int i = 0; i < PP; i++)
            pow2[i] = (1<<i);

        for(int i = 0; i <= n; i++)
        {
            edge[i].clear();
            vis[i] = false;
        }

    }

    void addedge(int u ,int v)
    {
        edge[u].push_back(v);
    }

    void dfs(int u ,int d) 
    {
        tim++;  
        vis[u] = true;
        nodeId[tim] = u;
        first[u] = tim; 
        dep[tim] = d;  
        int sz = edge[u].size();
        for(int i = 0; i < sz; i++)
        {
            int v = edge[u][i];
            if(vis[v] == false)
            {
                dfs(v, d + 1);
                tim++;
                nodeId[tim] = u;  
                dep[tim] = d;
            }
        }
    }

    void ST(int len)
    {
        int k = (int)(log(len+1.0) / log(2.0));

        for(int i = 1; i <= len; i++)
            dp[i][0] = i;

        for(int j = 1; j <= k; j++)
            for(int i = 1; i + pow2[j] - 1 <= len; i++)
            {
                int a = dp[i][j-1]; 
                int b = dp[i+pow2[j-1]][j-1];
                if(dep[a] < dep[b]) dp[i][j] = a;
                else dp[i][j] = b;
            }
    }

    int RMQ(int x ,int y)
    {
        int k = (int)(log(y-x+1.0) / log(2.0));
        int a = dp[x][k];
        int b = dp[y-pow2[k]+1][k];
        if(dep[a] < dep[b]) return a;
        else return b;
    }

    int LCA(int u ,int v)
    {
        if(u > v) swap(u, v);
        int x = first[u];
        int y = first[v];
        if(x > y) swap(x,y);
        int index = RMQ(x,y);
        return nodeId[index];
    }
};
LCA_RMQ t;

int tot;
void Insert(string s,int rt)
{
    ceng[rt] = 0;
    int len=s.length();
    for(int i=0;i<len;i++)
    {
        int x=s[i]-'a';
        if(tire[rt][x]==0) {
            tire[rt][x]=tot++;
            ceng[tire[rt][x]] = i + 1;
            t.addedge(rt, tire[rt][x]);
        }
//rt        printf("%c %d  %d\n", x + 'a', tire[rt][x], ceng[tire[rt][x]]);
        rt=tire[rt][x];
        flag[rt] = 0;
    }
    flag[rt]=1;
}

char str[55][15];
set<string> ss;
int ye[maxn];
int main()
{
    int tt;
    scanf("%d",&tt);
    for(int kase = 1; kase <= tt; kase++) {
        int n;
        scanf("%d",&n);
        tot = 1;
        memset(tire, 0, sizeof(tire));
        memset(flag, 0, sizeof(flag));
        memset(ceng, 0, sizeof(ceng));
        tot = 2;
        t.init(100000);
        ss.clear();
        string s1;
        for(int i = 0; i < n; i++) {
            getchar();
            cin >> s1;
            ss.insert(s1);    
        }

    set<string>::iterator it;
for(it = ss.begin(); it != ss.end(); it++) {
    s1 = *it;
    Insert(s1, 1);
}    
        t.n = tot;
        t.tim = 0;
        t.dfs(1, 1);
        t.ST(2 * t.n - 1);
        int ye_tot = 0;
        for(int i = 1; i < tot; i++) {
            if(flag[i] == true) {
                ye[ye_tot++] = i;
            }
        }
        int hh = 0;
        for(int i = 0; i < 26; i++) {
            if(tire[1][i] != 0) {
                hh++;
            }
        }
        if(hh == 1) {
            ye[ye_tot++] = 1;
        }
//        for(int i = 0; i< ye_tot; i++) {
//            printf("%d ", ye[i]);
//        }puts("");
        int ans = 1000000000;
        for(int i = 1; i < tot; i++) {
            int sum = 0;
            for(int j = 0; j < ye_tot; j++) {
                int rt = t.LCA(i, ye[j]);
                sum += fabs(ceng[i] - ceng[rt]) + fabs(ceng[ye[j]] - ceng[rt]);
            }
            
            ans = min(ans, sum);
        }
        printf("Case #%d: %d\n",kase, ans);
    }
    return 0;
}

 

第二种方法  直接对每个点dfs  由于总共的点数为500个  所用时间复杂度用500*500  

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

const int maxn = 505;


struct Edge {
    int to, next;
}e[maxn];
int sum;
int head[maxn];

void add(int u, int v) {
    e[sum].to = v;
    e[sum].next = head[u];
    head[u] = sum++;
}


int tire[maxn][30];
int tot;


void init() {
    memset(tire, 0, sizeof(tire));
    memset(head, 0, sizeof(head));
    sum = 1;
    tot = 1;
}

void Insert(char *s, int rt) {
    for(int i = 0; s[i]; i++) {
        int x = s[i] - 'a';
        if(tire[rt][x] == 0) {
            tire[rt][x] = tot++;
            add(rt, tire[rt][x]);
            add(tire[rt][x], rt);
        }
//        printf("%c   %d\n", s[i], tire[rt][x]);
        rt = tire[rt][x];
    }
}

int ans;

int vis[maxn];
void dfs(int u, int de) {
    vis[u] = 1;
    bool flag = false;
    for(int i = head[u]; i; i = e[i].next) {
        int v = e[i].to;
        if(!vis[v]) {
            vis[v] = 1;
            flag = true;
            dfs(v, de + 1);
        }
    }
    if(flag == false) {
        ans += de;
    }
}

int main() {
    int t, n;
    char str[15];
    scanf("%d",&t);
    int ka = 1;
    while(t--) {
        scanf("%d",&n);
        init();
        while(n--) {
            scanf("\n%s",str);
//            printf("%s\n",str);
            Insert(str, 0);
        }
        int _ans = 1000000000;
        for(int i = 0; i < tot; i++) {
            ans = 0;
            memset(vis, 0, sizeof(vis));
            dfs(i, 0);
            _ans = min(_ans, ans);
        }
        printf("Case #%d: %d\n",ka++,_ans);
    }
}