poj1040 Transportation（DFS）

题目链接

http://poj.org/problem?id=1040

题意

城市A，B之间有m+1个火车站，第一站A站的编号为0，最后一站B站的编号为m，火车最多可以乘坐n人。火车票的票价为票上终点站的编号减去起点站的编号。输入火车票订单的数目orderNums，接着输入orderNums个订单，每个订单由3个数字s，e，p组成，分别表示订单的起点站，终点站，该订单的人数，必须全部接受订单上的乘客或者全部不接受，求铁路公司最多可以赚多少钱。

思路

对于一个订单来说，有两种情况：接受和不接受。我们只需将所有可能的情况枚举出来，然后求在每一种情况下，铁路公司所赚的钱的最大值即可，这种枚举很适合使用dfs来解决。为了简化求解，我们要保证乘客是按火车站的编号顺序来上车，所以要将订单按订单起点的编号从低到高排序，若起点相同，则按终点编号从低到高排序。

代码

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

struct Order
{
    int s;  //起点
    int e;  //终点
    int p;  //人数

    Order(int s, int e, int p):s(s), e(e), p(p){}
};

bool cmp(Order o1, Order o2)    //将订单排序
{
    if(o1.s==o2.s)
        return o1.e<o2.e;
    return o1.s<o2.s;
}

const int N = 10;
vector<Order> orders;
int n, m, orderNums;
int down[N];    //down[i]表示第i站下车的人数
int ans;

/*
* p : 当前车上的人数
* cur : 当前处理第cur个订单
* sum : 当前赚的钱数
*/
void dfs(int p, int cur, int sum)
{
    if(cur==orderNums)
    {
        ans = max(ans, sum);
        return;
    }

    if(cur>0)   //减去上一个订单的下车人数
    {
        for(int i=orders[cur-1].s+1; i<=orders[cur].s; i++)
            p-=down[i]; //减去下车的人数
    }
    if(p+orders[cur].p <= n)
    {
        down[orders[cur].e] += orders[cur].p;
        dfs(p+orders[cur].p, cur+1, sum + (orders[cur].e-orders[cur].s)*orders[cur].p);
        down[orders[cur].e] -= orders[cur].p;   //注意恢复现场，便于回溯
    }
    dfs(p, cur+1, sum);
}

int main()
{
    //freopen("poj1040.txt", "r", stdin);
    while(cin>>n>>m>>orderNums && n)
    {
        ans = -1;
        orders.clear();
        memset(down, 0, sizeof(down));
        for(int i=0; i<orderNums; i++)
        {
            int s, e, p;
            cin>>s>>e>>p;
            orders.push_back(Order(s, e, p));
        }

        sort(orders.begin(), orders.end(), cmp);
        dfs(0, 0, 0);
        cout<<ans<<endl;
    }
    return 0;
}

 一点思考

除了上面代码中的dfs写法，还可以换一种dfs写法，思路是在循环遍历订单时进行dfs，我感觉这种方法比上一种dfs方法要容易想一点，但实现起来比上一种要麻烦一些。代码和上面的代码基本一样，只是dfs函数有所不同。代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
using namespace std;

struct Order
{
    int s;  //起点
    int e;  //终点
    int p;  //人数

    Order(int s, int e, int p) :s(s), e(e), p(p) {}
};

bool cmp(Order o1, Order o2)    //将订单排序
{
    if (o1.s == o2.s)
        return o1.e<o2.e;
    return o1.s<o2.s;
}

const int N = 10;
vector<Order> orders;
int n, m, orderNums;
int down[N];    //down[i]表示第i站下车的人数
int ans;

/*
* p : 当前车上的人数
* pre : 当前处理订单的上一个接受订单
* cur : 当前处理第cur个订单
* sum : 当前赚的钱数
*/
void dfs(int p, int pre, int cur, int sum)
{
    if (cur>0 && cur<orderNums)   //减去上一个订单的下车人数
    {
        for (int i = orders[pre].s + 1; i <= orders[cur].s; i++)
            p -= down[i]; //减去下车的人数
    }
    for (int i = cur; i<orderNums; i++)
    {
        bool flag = false;
        for (int j = orders[cur].s + 1; j <= orders[i].s; j++)    //测试是否能接受订单i
        {
            p -= down[j]; //减去下车的人数 (位置1)
            flag = true;
        }
        if (p + orders[i].p <= n)
        {
            pre = i;
            down[orders[i].e] += orders[i].p;
            dfs(p + orders[i].p, pre, i + 1, sum + (orders[i].e - orders[i].s)*orders[i].p);
            down[orders[i].e] -= orders[i].p;   //注意恢复现场，便于回溯
        }
        if (flag)    //只有在位置1减了的情况下再加回来
        {
            for (int j = orders[cur].s + 1; j <= orders[i].s; j++)
                p += down[j]; //加上位置1减去的人数,恢复现场，便于回溯
        }
    }
    ans = max(ans, sum);
}

int main()
{
    //freopen("poj1040.txt", "r", stdin);
    while (cin >> n >> m >> orderNums && n)
    {
        ans = -1;
        orders.clear();
        memset(down, 0, sizeof(down));
        for (int i = 0; i<orderNums; i++)
        {
            int s, e, p;
            cin >> s >> e >> p;
            orders.push_back(Order(s, e, p));
        }

        sort(orders.begin(), orders.end(), cmp);
        dfs(0, 0, 0, 0);
        cout << ans << endl;
    }
    return 0;
}

这份代码提交后内存占用与第一份代码相同，时间上稍微慢了一点点。