Uva 116,单向TSP

题目链接:https://uva.onlinejudge.org/external/1/116.pdf

和矩形嵌套,巴比伦塔差不多。

题意:

给出矩阵,这个矩阵是环形的,就是说第一行的上一行是最后一行,最后一行的下一行是第一行,要求从最左边一列走到最右边一列,路径上的和最小。多组解输出字典序最小的解。

分析:

DAG多段图,dp(i,j)从第i行,第j列出发的最优解,然后走一遍每一行的第一列。

这里的字典序最小,每次决策时的三个选择,每一行,重新排个序,这样就保证了字典序最小。

姜来是老的辣,写了好久不知道WA在哪里,快写炸了。然后还是参考了下刘汝佳的写法,确实比我写的好一点,借鉴一下。

#include <bits/stdc++.h>

using namespace std;

#define INF 0x3f3f3f3f

int a[105][105];
int dp[105][105];
int path[105][105];

int main()
{
    //freopen("in.txt","r",stdin);
    int m,n;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        for(int i=0; i<m; i++)
        {
            for(int j=0; j<n; j++)
            {
                scanf("%d",&a[i][j]);
            }
        }

        memset(dp,INF,sizeof(dp));

        int ans = INF+1;
        for(int j=n-1; j>=0; j--)
        {
            for(int i=0; i<m; i++)
            {
                if(j==n-1) dp[i][j] = a[i][j];
                else
                {
                    int row[3] = {i,i-1,i+1};
                    if(i==0) row[1] = m-1;
                    if(i==m-1) row[2] = 0;
                    sort(row,row+3);

                    for(int k=0; k<3; k++)
                    {
                        int v = dp[row[k]][j+1] + a[i][j];
                        if(v<dp[i][j])
                        {
                            dp[i][j] = v;
                            path[i][j] = row[k];
                        }
                    }

                }

            }
        }

        int flag;
        for(int i=0;i<m;i++) {
            if(ans>dp[i][0])
            {
                ans = dp[i][0];
                flag = i;
            }
        }

        printf("%d",flag+1);
        for(int j=1;j<n;j++) {
            printf(" %d",path[flag][j]+1);
            flag = path[flag][j];
        }
        puts("");
        printf("%d\n",ans);

    }

    return 0;
}

/*
#include <cstdio>
#include <algorithm>
#include <cstring>

using namespace std;

#define INF 0x3f3f3f3f

int a[15][105];
int dp[15][105];
int path[15][105];
int m,n;

int main()
{
    //freopen("in.txt","r",stdin);

    while(scanf("%d%d",&m,&n)==2&&m) {

        for(int i=1;i<=m;i++) {
            for(int j=1;j<=n;j++)
                scanf("%d",&a[i][j]);
        }

        for(int i=1;i<=m;i++) {
            for(int j=1;j<=n;j++)
                dp[i][j] = INF;
        }

        memset(path,0,sizeof(path));

        for(int i=n;i>=1;i--) {
            for(int j=1;j<=m;j++) {
                if(i==n) {
                    dp[j][i] = a[j][i];
                    path[j][i] = j;
                }
                else {
                    if(j==1) {

                        int temp = INF;
                        int f;

                        if(temp>dp[j][i+1]) {
                            temp = dp[j][i+1];
                            f = j;
                        }
                        if(temp>dp[j+1][i+1]) {
                            temp = dp[j+1][i+1];
                            f = j+1;
                        }
                        if(temp>dp[m][i+1]) {
                            temp = dp[m][i+1];
                            f = m;
                        }

                        dp[j][i] = a[j][i] + temp;
                        path[j][i] = f;

                    }
                    else if(j==m) {

                        int temp = INF;
                        int f;
                        if(temp>dp[1][i+1]) {
                            temp = dp[1][i+1];
                            f = 1;
                        }
                        if(temp>dp[j-1][i+1]) {
                            temp = dp[j-1][i+1];
                            f = j-1;
                        }
                        if(temp>dp[j][i+1]) {
                            temp = dp[j][i+1];
                            f = j;
                        }

                        dp[j][i] = a[j][i] + temp;
                        path[j][i] = f;

                    }
                    else {
                        int temp = INF;
                        int f;
                        if(temp>dp[j-1][i+1])
                        {
                            temp = dp[j-1][i+1];
                            f = j-1;
                        }
                        if(temp>dp[j][i+1]) {
                            temp = dp[j][i+1];
                            f = j;
                        }
                        if(temp>dp[j+1][i+1]) {
                            temp = dp[j+1][i+1];
                            f = j+1;
                        }

                        dp[j][i] = a[j][i]+temp;
                        path[j][i] = f;
                    }

                }
            }
        }

        int flag = 0;
        int ans = INF+1;
        for(int i=1;i<=m;i++) {
            if(ans>dp[i][1])
            {
                flag = i;
                ans = dp[i][1];
            }
        }

        printf("%d",flag);

        for(int i=2;i<=n;i++) {
            printf(" %d",path[flag][i-1]);
            flag = path[flag][i-1];
        }
        puts("");
        printf("%d\n",ans);

    }

    return 0;
}
*/

#include <bits/stdc++.h>

using namespace std;

#define INF 0x3f3f3f3f

int a[105][105];
int dp[105][105];
int path[105][105];

int main()
{
    freopen("in.txt","r",stdin);
    int m,n;
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        for(int i=0; i<m; i++)
        {
            for(int j=0; j<n; j++)
            {
                scanf("%d",&a[i][j]);
            }
        }

        for(int i=0; i<m; i++)
        {
            for(int j=0; j<n; j++)
                dp[i][j] = INF;
        }

        int ans = INF+1;
        for(int j=n-1; j>=0; j--)
        {
            for(int i=0; i<m; i++)
            {
                if(j==n-1) dp[i][j] = a[i][j];
                else
                {
                    int row[3] = {i,i-1,i+1};
                    if(i==0) row[1] = m-1;
                    if(i==m-1) row[2] = 0;
                    sort(row,row+3);

                    for(int k=0; k<3; k++)
                    {
                        int v = dp[row[k]][j+1] + a[i][j];
                        if(v<dp[i][j])
                        {
                            dp[i][j] = v;
                            path[i][j] = row[k];
                        }
                    }

                }

            }
        }

        int flag;
        for(int i=0; i<m; i++)
        {
            if(ans>dp[i][0])
            {
                ans = dp[i][0];
                flag = i;
            }
        }

        printf("%d",flag+1);
        for(int i = path[flag][0], j = 1; j < n; i = path[i][j], j++)
            printf(" %d", i+1);
        puts("");
        printf("%d\n",ans);

    }

    return 0;
}

时间: 2024-07-30 14:47:11

Uva 116,单向TSP的相关文章

uva 116 - Unidirectional TSP (动态规划)

第一次做动规题目,以下均为个人理解以及个人方法,状态转移方程以及状态的定义也是根据个人理解,请过路大神指教. 状态:每一列的每一个数[ i ][ j ]都是一个状态: 然后定义状态[ i ][ j ]的指标函数d[ i ][ j ]为从[ i ][ j ]向右出发的可以得到的最小的整数和: 状态转移方程:d[ i ][ j ]=min(d[ i+1 ][ j+1 ][ i-1 ][ j+1 ][ i ][ j+1 ])+a[ i ][ j ]; 其中a[ i ][ j ]为当前位置的数值: 然后

uva 116 Unidirectional TSP【号码塔+打印路径】

主题: uva 116 Unidirectional TSP 意甲冠军:给定一个矩阵,当前格儿童值三个方向回格最小值和当前的和,就第一列的最小值并打印路径(同样则去字典序最小的). 分析:刚開始想错了,从前往后走,这种话没有办法控制字典序最小,用dfs标记了一下超时了. 事实上从后往前走就好了. 以后一定先想清楚顺序.然后dp的时候选择字典序最小的.用father数据记录就可以. AC代码: #include<iostream> #include<cstdio> #include&

uva 116 Unidirectional TSP (DP)

uva 116 Unidirectional TSP Background Problems that require minimum paths through some domain appear in many different areas of computer science. For example, one of the constraints in VLSI routing problems is minimizing wire length. The Traveling Sa

uva 116 Unidirectional TSP【数塔+打印路径】

题目: uva 116 Unidirectional TSP 题意:给出一个矩阵,当前的格子值为后面三个方向的格子最小值和当前的和,就第一列的最小值并打印路径(相同则去字典序最小的). 分析:刚开始想错了,从前往后走,这样的话没有办法控制字典序最小,用dfs标记了一下超时了. 其实从后往前走就好了.以后一定先想清楚顺序,然后dp的时候选择字典序最小的,用father数据记录即可. AC代码: #include<iostream> #include<cstdio> #include&

UVA 116 Unidirectional TSP(DP最短路字典序)

Description  Unidirectional TSP  Background Problems that require minimum paths through some domain appear in many different areas of computer science. For example, one of the constraints in VLSI routing problems is minimizing wire length. The Travel

uva 116 Unidirectional TSP 单向TSP 问题,经典dP(路径输出注意规划方向)

Unidirectional TSP Time Limit:3000MS Memory Limit:0KB 64bit IO Format:%lld & %llu Submit Status Practice UVA 116 Appoint description: Description Download as PDF Background Problems that require minimum paths through some domain appear in many differ

UVA - 116 - Unidirectional TSP (简单DP + 打印路径)

题目传送:UVA - 116 思路:可以定义状态为dp[i][j] 为从第i行第j列开始往后走到第n列(总共n列)的最小值(赋初始值为无穷),且状态方程很好推出来:dp[i][j] = a[i][j] + max(dp[i-1][j+1], dp[i][j+1], dp[i+1][j+1]);    最后最优解  ans = max(dp[i][1])(1<=i<=m); 不过这题难点不在这里,而是可能有多组最小值,输出字典序最小的那组: 这里要注意好递推的方向,只能从右往左递推列数,而如果从

UVa 116 Unidirectional TSP(DP)

题意  一个n*m的环形矩阵(第一行和最后一行是相邻的)  从第一列任意位置出发  只能往右上,右,右下3个方向走  求走到第m列经过的的最小数字和 基础DP  横着的数塔问题 #include <bits/stdc++.h> #define l(x) d[x][j+1] using namespace std; const int N = 105; int n, m, g[N][N], d[N][N], fol[N][N]; int main() { int n, m, u, b, t, k

UVA 116 Unidirectional TSP

Unidirectional TSP Problems that require minimum paths through some domain appear in many different areas of computer science. For example, one of the constraints in VLSI routing problems is minimizing wire length. The Traveling Salesperson Problem (

uva 116 Unidirectional TSP dp + 打印路径

// uva116 Unidirectional TSP // 这题是在紫书(page 270)上看到的,个人理解就是数塔的升级版 // dp[i][j]表示从(i,j)出发到终点所达到的最大价值 // 所以很明显j是逆序的 // 状态转移方程为 // dp[i][j] = min(dp[i][j],dp[row[k]][j+1]+mp[i][j]) // rows[k]表示三行中的一行i,i-1,i+1,特判一下,排个序 // (因为多解时输出字典序最小的值) // 这题唯一比较难的地方就是打