HDU 4511 小明系列故事——女友的考验（AC自动机 + dp）

最新推荐文章于 2020-02-12 03:41:20 发布

aozil_yang

最新推荐文章于 2020-02-12 03:41:20 发布

阅读量393

点赞数

CC 4.0 BY-SA版权

分类专栏： HDU AC自动机 DP 文章标签： AC自动机 dp HDU

本文链接：https://blog.youkuaiyun.com/aozil_yang/article/details/77427984

HDU 同时被 3 个专栏收录

158 篇文章

订阅专栏

101 篇文章

订阅专栏

AC自动机

15 篇文章

订阅专栏

本文介绍了一个利用AC自动机解决最短路径问题的方法，具体地，通过AC自动机构建禁止路径的自动识别机制，并结合动态规划算法，解决了从起点到终点避免特定路径的情况下寻找最短路径的问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：

给你n个点，你在1号点，要到n 号点，有m 种路径不能走，求1到n 的最短路长度。

思路：

m 种路径不能走，很容易想到AC自动机。求距离最短。

还是将m 种路径建立成自动机，一个结点非法，不仅他是m 种路径的末尾，还包括m 种路径子串的话也是非法的。

我们令dp[i][j] 表示在目前在i 点， j 状态的最短距离。（j 为自动机上的结点）

那么转移就很简单了

枚举上一个点的位置和状态，来转到下个点即可。

吐槽：

dp 状态想错了写了一上午都不过样例，换了个状态就很轻松了。 dp 还是得多换换思路想个合适的状态。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cmath>
using namespace std;


struct node{
    double x, y;
    void read(){
        scanf("%lf %lf", &x, &y);
    }
}p[57];

double dis[57][57];
const double oo = 1e18;
const int maxn = 1000;
struct Trie{
    int L, root;
    int flag[maxn];
    int next[maxn][52];
    int fail[maxn];
    int kind[maxn];
    double dp[52][maxn];


    void init(){
        L = 0;
        root = newnode();
        kind[root] = 1;
    }
    int newnode(){
        for (int i = 1; i <= 50; ++i){
            next[L][i] = -1;
        }
        flag[L] = 0;
        return L++;
    }
    void bfs(){
        queue<int>q;
        fail[root] = root;
        for (int i = 1; i <= 50; ++i){

            if (next[root][i] == -1) {
                next[root][i] = root;
            }
            else {
                fail[next[root][i] ] = root;
                q.push(next[root][i]);
            }
        }

        while(!q.empty()){
            int u = q.front(); q.pop();

            for (int i = 1; i <= 50; ++i){
                if (next[u][i] == -1){
                    next[u][i] = next[fail[u] ][i];

                }
                else{
                    fail[next[u][i] ] = next[fail[u] ][i];
                    q.push(next[u][i]);
                }


            }



        }
    }


    void deal(){
        for (int i = 0; i < L; ++i){
            if (flag[i]) continue;
            int tmp = i;
            while(tmp != root){
                if (flag[tmp]){
                    flag[i] = 1;
                    break;
                }
                tmp = fail[tmp];
            }
        }

    }

    void insert(int* a){
        int nod = root;
        for (int i = 1; i <= a[0]; ++i){
            int id = a[i];
            if (next[nod][id] == -1){
                next[nod][id] = newnode();
                kind[next[nod][id] ] = id;
            }
            nod = next[nod][id];
        }
        flag[nod] = 1;
    }


    void solve(int n){
        for (int i = 0; i <= n; ++i){
            for (int j = 0; j < L; ++j){
                dp[i][j] = oo;
            }
        }

        dp[1][next[root][1] ] = 0;
        double ans = oo;
        for (int i = 1; i <= n; ++i){
            for (int j = 0; j < L; ++j){
                if (dp[i][j] >= oo) continue;
                if (flag[j]) continue;
                for (int k = 1; k <= n; ++k){
                    int nx = next[j][k];
                    if (flag[nx]) continue;
                    dp[k][nx] = min(dp[k][nx], dp[i][j] + dis[i][k]);
                }
            }
        }

        for (int i = 0; i < L; ++i){
            ans = min(ans, dp[n][i]);
        }

        if (ans >= 1e18) puts("Can not be reached!");
        else printf("%.2f\n", ans);

    }
}ac;

int a[10];
double get(int i, int j){
    return sqrt((p[j].y - p[i].y) * (p[j].y - p[i].y) + (p[j].x - p[i].x) * (p[j].x - p[i].x));
}
int main(){
    int n, m;
    while(~scanf("%d %d",&n, &m) && (n || m)){
        p[0].x = p[0].y = 0;
        for (int i = 1; i <= n; ++i){
            p[i].read();
        }
        for (int i = 0; i <= n; ++i){
            dis[i][i] = 0;
            for (int j = i + 1; j <= n; ++j){
                dis[i][j] = dis[j][i] = get(j, i);
            }
        }
        ac.init();
        for (int i = 0; i < m; ++i){
            scanf("%d",&a[0]);
            for (int j = 1; j <= a[0]; ++j){
                scanf("%d", &a[j]);
            }
            ac.insert(a);
        }
        ac.bfs();
        ac.deal();
        ac.solve(n);
    }
    return 0;
}

小明系列故事——女友的考验

Time Limit: 500/200 MS (Java/Others) Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 1645 Accepted Submission(s): 440

Problem Description

　　终于放寒假了，小明要和女朋友一起去看电影。这天，女朋友想给小明一个考验，在小明正准备出发的时候，女朋友告诉他，她在电影院等他，小明过来的路线必须满足给定的规则：
　　1、假设小明在的位置是1号点，女朋友在的位置是n号点，则他们之间有n-2个点可以走，小明每次走的时候只能走到比当前所在点编号大的位置；
　　2、小明来的时候不能按一定的顺序经过某些地方。比如，如果女朋友告诉小明不能经过1 -> 2 -> 3，那么就要求小明来的时候走过的路径不能包含有1 -> 2 -> 3这部分，但是1 -> 3 或者1 -> 2都是可以的，这样的限制路径可能有多条。
　　这让小明非常头痛，现在他把问题交给了你。
　　特别说明，如果1 2 3这三个点共线，但是小明是直接从1到3然后再从3继续，那么此种情况是不认为小明经过了2这个点的。
　　现在，小明即想走最短的路尽快见到女朋友，又不想打破女朋友的规定，你能帮助小明解决这个问题吗？

Input

　　输入包含多组样例，每组样例首先包含两个整数n和m，其中n代表有n个点，小明在1号点，女朋友在n号点，m代表小明的女朋友有m个要求；
　　接下来n行每行输入2个整数x 和y（x和y均在int范围），代表这n个点的位置（点的编号从1到n）；
　　再接着是m个要求，每个要求2行，首先一行是一个k，表示这个要求和k个点有关，然后是顺序给出的k个点编号，代表小明不能走k1 -> k2 -> k3 ……-> ki这个顺序的路径；
　　n 和 m等于0的时候输入结束。

　　 [Technical Specification]
　　2 <= n <= 50
　　1 <= m <= 100
　　2 <= k <= 5

Output

　　对于每个样例，如果存在满足要求的最短路径，请输出这个最短路径，结果保留两位小数；否则，请输出”Can not be reached!” （引号不用输出）。

Sample Input

Sample Output

  
   2.00
Can not be reached!
21.65

Source

2013腾讯编程马拉松初赛第二场（3月22日）

Recommend

liuyiding | We have carefully selected several similar problems for you: 6160 6159 6158 6157 6156

Statistic | Submit | Discuss | Note

HDU 4511 小明系列故事——女友的考验 （AC自动机 + dp）

小明系列故事——女友的考验

HDU 4511 小明系列故事——女友的考验（AC自动机 + dp）