链接：http://poj.org/problem?id=1040

Transportation

Time Limit: 1000MS Memory Limit: 10000K

Total Submissions: 4235 Accepted: 1725

Description

Ruratania is just entering capitalism and is establishing new enterprising activities in many fields in- cluding transport. The transportation company TransRuratania is starting a new express train from city A to city B with several
stops in the stations on the way. The stations are successively numbered, city A station has number 0, city B station number m. The company runs an experiment in order to improve passenger transportation capacity and thus to increase its earnings. The train
has a maximum capacity n passengers. The price of the train ticket is equal to the number of stops (stations) between the starting station and the destination station (including the destination station). Before the train starts its route from the city A, ticket
orders are collected from all onroute stations. The ticket order from the station S means all reservations of tickets from S to a fixed destination station. In case the company cannot accept all orders because of the passenger capacity limitations, its rejection
policy is that it either completely accept or completely reject single orders from single stations.

Write a program which for the given list of orders from single stations on the way from A to B determines the biggest possible total earning of the TransRuratania company. The earning from one accepted order is the product of the number of passengers included
in the order and the price of their train tickets. The total earning is the sum of the earnings from all accepted orders.

Input

The input file is divided into blocks. The first line in each block contains three integers: passenger capacity n of the train, the number of the city B station and the number of ticket orders from all stations. The next lines contain
the ticket orders. Each ticket order consists of three integers: starting station, destination station, number of passengers. In one block there can be maximum 22 orders. The number of the city B station will be at most 7. The block where all three numbers
in the first line are equal to zero denotes the end of the input file.

Output

The output file consists of lines corresponding to the blocks of the input file except the terminating block. Each such line contains the biggest possible total earning.

Sample Input

10 3 4

0 2 1

1 3 5

1 2 7

2 3 10

10 5 4

3 5 10

2 4 9

0 2 5

2 5 8

0 0 0

Sample Output

19

34

Source

Central Europe 1995

大意——从A到B有若干个车站，编号从0到m。列车的最大载客量是n。每次列车开车之前，会从各个车站收集订票信息。一条订票信息包含：起点站。终点站，人数。票价在数值上等于起点站与终点站之间的车站数（包含终点站，不包含起点站）。

因为列车的最大载客量是一定的。所以不一定能接受所有的订票。对于一条订票。仅仅能所有接受，或者是所有拒绝。如今给你最大载客量n。车站总数m，以及order条订票信息。要你计算出接受某些订票使之利润最大。而且输出这个最大利润。

思路——显然这是一个DFS的问题。但必须进行剪枝操作。

首先按起点站进行排序。假设起点站同样。则按终点站排。

然后按着顺序DFS：每接受一个订单，就把沿线所在站载客量所有加上这个订单中的人数。假设发现哪个站的人数超过了最大载客量n，就必须停下来，这个订单是不能接受的，就把所在站载客量中加上的人数所有减下来。

假设所有沿线所在站都没有超过n，就能够加上该订单的利润，開始測试下一个订单，測试完毕之后取消沿线所在站加的人数回溯。每当開始測试订单时，就把已经能获得的利润用參数的形式传递过去，保存这个最大值max。最后把所有的情况都遍历之后，输出max即得结果。

复杂度分析——时间复杂度:O(order*log(order))+O((n/passe)^order),空间复杂度:O(order)

附上AC代码：

#include <iostream>
#include <cstdio>
#include <iomanip>
#include <string>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
using namespace std;
const double PI = acos(-1.0);
const double E = exp(1.0);
const short maxorder = 22; // 最大订票量
const short maxsta = 8; // 最大车站数，包含首站
short cap, sta, order; // 分别表示火车的容量，车站数(不包含首站)和订票量
short down[maxsta]; // 第i站下车的人数，包含首站
short ans; // 终于结果
struct ticket
{
    short start, des, pass;
    bool operator < (const ticket & p) const{
        if (start == p.start)
            return des < p.des;
        return start < p.start;
    } // 按此规则排序
} ord[maxorder];

void dfs(short ord_num, short passe, short money);

int main()
{
    ios::sync_with_stdio(false);
    while (cin >> cap >> sta >> order && (cap || sta || order))
    {
        for (int i=0; i<order; i++)
            cin >> ord[i].start >> ord[i].des >> ord[i].pass; // 订票信息
        sort(ord, ord+order);
        ans = 0;
        dfs(0, 0, 0);
        cout << ans << endl;
    }
    return 0;
}

void dfs(short ord_num, short passe, short money)
{
    if (ord_num == order) // 订票量所有检查完成
    {
        ans = max(ans, money);
        return;
    }
    if (ord_num > 0)
        for (int i=ord[ord_num-1].start+1; i<=ord[ord_num].start; ++i)
            passe -= down[i]; // 减去下车人数，计算当前车内人数
    if (passe+ord[ord_num].pass <= cap) // 检查是否超载
    {
        down[ord[ord_num].des] += ord[ord_num].pass; // 不超载。接受订票
        dfs(ord_num+1, passe+ord[ord_num].pass, money+ord[ord_num].pass*(ord[ord_num].des-ord[ord_num].start));
        down[ord[ord_num].des] -= ord[ord_num].pass; // 恢复现场，以便后面回溯
    }
    dfs(ord_num+1, passe, money); // 不接受订票
}