UVA103动态规划之DAG上的最长路及其字典序

本文介绍了一种使用记忆化搜索解决无起点终点图中寻找最长路径的问题,并提供了详细的C++实现代码。通过构建图模型并利用动态规划思想,算法能够高效地找到从任意节点出发的最长路径。

小白书上讲的很清楚,因为没有起点和终点,所以这题用记忆化搜索。

代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<cmath>
#include<algorithm>
#include<string>
#include<map>
#include<queue>
#include<stack>
#include<set>
#include<vector>
#define LL long long
using namespace std;
const int maxn=1e4+10;
const double eps=1e-6;
int k,n;
int a[40][20];
int b[40][40];
int dp[40];
int ddp(int i)
{
    int &ans=dp[i];
    if(ans)
        return ans;
    ans=1;
    for(int j=0;j<k;j++)
    {
        if(b[i][j])
            ans=max(ans,ddp(j)+1);
    }
    return ans;
}
void init(int k,int n)
{
    memset(b,0,sizeof(b));
    for(int i=0;i<k;i++)
    {
        for(int j=0;j<k;j++)
        {
            int flag=1;
            for(int t=0;t<n;t++)
            {
                if(a[i][t]<=a[j][t])
                {
                    flag=0;
                    break;
                }
            }
            if(flag)
                b[i][j]=1;
        }
    }
}
void print(int i)
{
    for(int j=0;j<k;j++)
    if(b[i][j]&&dp[i]==dp[j]+1)
    {
        print(j);
        break;
    }
    cout<<i+1<<' ';
}
int main()
{
    while(cin>>k>>n)
    {
        for(int i=0;i<k;i++)
        {
            for(int j=0;j<n;j++)
                scanf("%d",&a[i][j]);
            sort(a[i],a[i]+n);
        }
        init(k,n);
        cout<<endl;
        memset(dp,0,sizeof(dp));
        for(int i=0;i<k;i++)
            dp[i]=ddp(i);
        int ans=0;
        int t;
        for(int i=0;i<k;i++)
        {
             if(dp[i]>ans)
             {
                 t=i;
                 ans=dp[i];
             }
        }

        if(ans)
        {
            cout<<ans<<endl;
            print(t);
            cout<<endl;
        }
        else
            cout<<0<<endl;
    }
    return 0;
}


### 不用记忆化搜索的搜索方法 在不使用记忆化搜索的情况下,可以通过**动态规划(DP)**或**广度优先搜索(BFS)**等方法来解决原本需要记忆化搜索的问题。这些方法通常采用**自底向上**的方式,而非记忆化搜索的**自顶向上**递归方式。以下是一些替代方法及其特点。 #### 1. 动态规划(自底向上) 动态规划是一种典型的迭代方法,它通过遍历所有可能的状态,并按照一定的顺序更新状态值,来避免递归带来的重复计算问题。与记忆化搜索相比,动态规划需要显式地设计状态转移方程,并按照一定的顺序填充状态表。 例如,在求解有向图中每个节点能到达的最大编号节点的问题中,可以使用拓扑排序结合动态规划的方法: ```cpp #include <iostream> #include <vector> #include <queue> using namespace std; vector<int> maxReachableIslandDP(int n, vector<vector<int>>& edges) { vector<vector<int>> graph(n + 1); vector<int> inDegree(n + 1, 0); for (const auto& edge : edges) { int u = edge[0]; int v = edge[1]; graph[u].push_back(v); inDegree[v]++; } vector<int> dp(n + 1); for (int i = 1; i <= n; ++i) { dp[i] = i; } queue<int> q; for (int i = 1; i <= n; ++i) { if (inDegree[i] == 0) { q.push(i); } } while (!q.empty()) { int u = q.front(); q.pop(); for (int v : graph[u]) { dp[v] = max(dp[v], dp[u]); inDegree[v]--; if (inDegree[v] == 0) { q.push(v); } } } return dp; } ``` 这种方法的时间复杂度为 $ O(N + M) $,适用于大规模图结构,且不会受到递归深度限制的影响。 #### 2. 广度优先搜索(BFS) 广度优先搜索是一种非递归的搜索方法,适用于图的可达性分析。BFS 通过队列来维护当前层的节点,并逐层扩展搜索范围,从而避免重复访问节点。BFS 通常用于求解最短路径、连通分量等问题。 例如,在求解图中每个节点可以到达的最远节点时,可以使用 BFS: ```cpp #include <iostream> #include <vector> #include <queue> using namespace std; vector<int> bfsMaxReachable(int n, vector<vector<int>>& edges) { vector<vector<int>> graph(n + 1); for (const auto& edge : edges) { int u = edge[0]; int v = edge[1]; graph[u].push_back(v); } vector<int> result(n + 1, 0); for (int i = 1; i <= n; ++i) { vector<bool> visited(n + 1, false); queue<int> q; q.push(i); visited[i] = true; int maxNode = i; while (!q.empty()) { int u = q.front(); q.pop(); for (int v : graph[u]) { if (!visited[v]) { visited[v] = true; maxNode = max(maxNode, v); q.push(v); } } } result[i] = maxNode; } return result; } ``` 这种方法虽然在时间复杂度上不如动态规划高效,但在某些特定场景下更容易实现。 #### 3. 拓扑排序 拓扑排序是一种适用于有向无环图(DAG)的算法,它能够按照依赖关系对节点进行排序。在处理图的可达性问题时,拓扑排序可以确保每个节点在被处理时,其所有前驱节点已经处理完毕,从而实现高效的动态规划更新。 拓扑排序与动态规划的结合可以有效避免递归带来的栈溢出问题,同时减少重复计算[^5]。 #### 4. 递推方法 递推方法是一种典型的非递归动态规划方式,它通过显式地遍历状态空间,并按照一定的顺序更新状态值。递推方法通常适用于状态转移关系明确的问题,例如最长递增子序列、背包问题等。 例如,最长递增路径问题可以使用递推方法进行优化: ```cpp #include <vector> #include <queue> #include <algorithm> using namespace std; int longestIncreasingPath(vector<vector<int>>& matrix) { int m = matrix.size(), n = matrix[0].size(); vector<vector<int>> outDegree(m, vector<int>(n, 0)); vector<vector<int>> dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}}; vector<vector<int>> dp(m, vector<int>(n, 1)); for (int i = 0; i < m; ++i) { for (int j = 0; j < n; ++j) { for (auto& dir : dirs) { int x = i + dir[0], y = j + dir[1]; if (x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] > matrix[i][j]) { outDegree[i][j]++; } } } } queue<pair<int, int>> q; for (int i = 0; i < m; ++i) { for (int j = 0; j < n; ++j) { if (outDegree[i][j] == 0) { q.push({i, j}); } } } int pathLength = 0; while (!q.empty()) { int sz = q.size(); for (int k = 0; k < sz; ++k) { auto [i, j] = q.front(); q.pop(); for (auto& dir : dirs) { int x = i - dir[0], y = j - dir[1]; if (x >= 0 && x < m && y >= 0 && y < n && matrix[x][y] < matrix[i][j]) { outDegree[x][y]--; dp[x][y] = max(dp[x][y], dp[i][j] + 1); if (outDegree[x][y] == 0) { q.push({x, y}); } } } } pathLength++; } return pathLength; } ``` 该方法结合了拓扑排序和动态规划的思想,避免了递归调用的开销,提高了运行效率[^2]。 --- ###
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值