poj 1724

最新推荐文章于 2021-02-03 19:31:21 发布

qte_acm

最新推荐文章于 2021-02-03 19:31:21 发布

阅读量668

点赞数

CC 4.0 BY-SA版权

分类专栏：搜索

本文链接：https://blog.youkuaiyun.com/zengchen__acmer/article/details/17323303

搜索专栏收录该内容

8 篇文章

订阅专栏

本文分享了一次使用邻接表优化图算法的经历，并介绍了如何通过改进数据结构从超时状态达到高效运行的过程。文中探讨了利用反向图求解终点到各点的最短路径和最小成本的方法，以及通过A*算法实现进一步优化的可能性。

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

这是一题简单的搜索问题，可我就是w+t了10多次。

一开始用的是vector来存储图（因为有重边），结果一直超时还加了优化，用邻接表之后，不加优化还过来，诶，直接代码，以后凡是图都用邻接表存储吧。

优化：可以求出终点到其他点的最短距离和最少花费，这个可以把图反过来求。
优化之后只要 98ms ，好像有个astar算法，可以0ms过，不知道是什么原理。

代码：

#include
#include
#include
#include
#include
using namespace std;

const int MAXN = 110;
const int INF = 0x3f3f3f3f;
struct node
{
    int u , d , c , pre;
}edge[10010];
struct node2
{
    int u , d , c , pre;
}grap[10010];
int pre[MAXN] , c[MAXN] , d[MAXN] , xy[MAXN];
int n , m , k , vis[MAXN];
int minsum , cost , sum ;

void init()
{
    memset(pre , -1, sizeof(pre));
    memset(vis , 0 , sizeof(vis));
    memset(xy , -1, sizeof(xy));
    cost = sum = 0;
    minsum = INF;
}

void dfs(int u)
{
    if(sum >= minsum || cost > k) return ;
    if(u == n)
    {
        minsum = sum;
        return ;
    }
    for(int i = pre[u] ; i != -1 ; i = edge[i].pre)
    {
        if(!vis[edge[i].u])
        {
            vis[edge[i].u] = 1;
            sum += edge[i].d ;
            cost += edge[i].c;
            dfs(edge[i].u);
            sum -= edge[i].d;
            cost -= edge[i].c;
            vis[edge[i].u] = 0;
        }
    }
}

void ford1()
{
    queueq;
    memset(vis , 0 , sizeof(vis));
    int i;
    for(i = 1; i <= n; i++) d[i] = INF;
    d[n] = 0;
    q.push(n);
    while(!q.empty())
    {
        int u = q.front(); q.pop();
        vis[u] = 0;
        for(i = xy[u] ; i != -1 ; i = grap[i].pre)
        {
            if(d[grap[i].u] > d[u] + grap[i].d)
            {
                d[grap[i].u] = d[u] + grap[i].d ;
                if(!vis[grap[i].u]) {q.push(grap[i].u) ; vis[grap[i].u] = 1;}
            }
        }
    }
}

void ford2()
{
    queueq;
    memset(vis , 0 , sizeof(vis));
    int i;
    for(i = 1; i <= n; i++) c[i] = INF;
    c[n] = 0;
    q.push(n);
    while(!q.empty())
    {
        int u = q.front(); q.pop();
        vis[u] = 0;
        for(i = xy[u] ; i != -1 ; i = grap[i].pre)
        {
            if(c[grap[i].u] > c[u] + grap[i].c)
            {
                c[grap[i].u] = c[u] + grap[i].c ;
                if(!vis[grap[i].u]) {q.push(grap[i].u) ; vis[grap[i].u] = 1;}
            }
        }
    }
}

int main()
{
    while(scanf("%d %d %d" , &k , &n , &m) != EOF)
    {
        init();
        int i , x , y , z , t;
        for(i = 0 ; i < m; i++)
        {
            scanf("%d %d %d %d" , &x , &y , &z , &t);
            edge[i].u = y , edge[i].d = z , edge[i].c = t;
            edge[i].pre = pre[x];
            pre[x] = i;
            grap[i].u = x , grap[i].d = z, grap[i].c = t;
            grap[i].pre = xy[y];
            xy[y] = i;
        }
        ford1();
        ford2();
        memset(vis , 0 , sizeof(vis));
        vis[1] = 1;
        dfs(1);
        if(minsum == INF) printf("-1\n");
        else printf("%d\n" , minsum);
    }
    return 0;
}

poj&nbsp;1724

poj 1724