Uva 301 - Transportation

Transportation

题目的意思是说列车从起始点开出的时候，他要收集每个站（包括起始站）的乘客的搭车订单，这些订单能够知道多少人从哪个站上车然后从哪个站下车。但由于列车载人的容量有限，它必须有所规划，即放弃有些站的订单票，在这样的情况下，求这列车能够得到的最大的利润值，单价是人从上车开始每经过一个站收权值为1的价格

做法先存储订票中的信息，再设一个数组表示[站1]，[站2]... .... 中此刻装载人的数量，每次检查一张票（也就是决定要不要放弃站的订票）时，大的方面来说是有两种可能，要或者不要，因为你要求最大的利润这是一般的做法，首先假设不放弃这票，那么先判断这些人上车后在经过的站里能不能容纳下，即没有超过列车的给定的容量，这是可以考虑这票，累加利润后继续检查（递归）下一张订票，递归回来要复原，复原之后考虑放弃这张票，继续递归。

但第一次会发现会超时， 2^22这个数还是挺大的，所以得考虑剪枝，这题剪枝的办法是在检查到一张票的时候，把剩下票的所有的利润值都试着累加起来再加上此刻的利润，跟之前存储的最大利润进行比较，如果最大利润还是比较大的话，那么就没有必要再递归下去了，反正最好的情况加起来都没有当前的最大利润大

题目链接:
http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=24&page=show_problem&problem=237

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAXN 24
typedef struct ticket{
int from, to;
int price, people;
}ticket;

ticket route[MAXN];
int visit[MAXN];
int road[10];
int max;

int judge(int cur, int n, int sum, int flag)
{
int i, temp;
for(temp=0,i=cur+flag; i<=n; ++i)
temp += route[i].price*route[i].people;
if(max > sum+temp) return 0;
else return 1;
}

int Traverse(int cur, int room, int n, int sum)
{
int temp, i, j, store1, store2, flag;
if(cur > n)
{
max = max > sum ? max : sum;
return sum;
}
flag = 1;
for(i=route[cur].from; i<route[cur].to; ++i)
{
if(road[i]+route[cur].people > room)
{
flag = 0;
break;
}
}
if(flag)
{
if(judge(cur, n, sum, 0))
{
visit[cur] = -1;
for(i=route[cur].from; i<route[cur].to; ++i) road[i] += route[cur].people;
Traverse(cur+1,room, n, sum+route[cur].price*route[cur].people);
for(i=route[cur].from; i<route[cur].to; ++i) road[i] -= route[cur].people;
visit[cur] = 0;
}
}
if(judge(cur, n, sum, 1))
Traverse(cur+1, room, n, sum);
return 0;
}

int main()
{

int num, city, order, i, cnt;
while(scanf("%d%d%d", &num, &city, &order) != EOF)
{
if(!num && !city && !order) break;
memset(visit, 0, sizeof(visit));
memset(road, 0, sizeof(road));
for(i=1; i<=order; ++i)
{
scanf("%d%d%d", &route[i].from, &route[i].to, &route[i].people);
route[i].price = route[i].to - route[i].from;
}
max = -1;
cnt = 0;
Traverse(1, num, order, cnt);
printf("%d\n", max);
}
return 0;
}

我的第一种做法并不是这样的，看起来好像复杂了不少，首先我先将票的信息根据票中的车站的终点（第一关键字）和站的起点（第二关键字）进行排序，还是一张票一张票检测，但检测的时候我先看这张票的起点，根据起点判断之前已接纳的票中是否有早已到达站的或者刚好达到站的，这时暂且将这些人数减掉已腾出载人的空间，这时将当前站需要上车的人数加上去看能否小于或等于车的容纳量，如果可以，加上上面所说的剪枝后递归下一张票，递归回来的后将刚才的暂且减掉的人数加回去，继续递归

不知道当初为什么会有这样的思路，根据是什么都不清楚，但测试了几组数据都没测出来，大神们可以看看

WA代码

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAXN 24
typedef struct ticket{
int from, to;
int price, people;
}ticket;

ticket route[MAXN];
int visit[MAXN];
int max;

int cmp(const void *a, const void *b)
{
int temp = (*(ticket *)a).to - (*(ticket *)b).to;
if(temp == 0)
return (*(ticket *)a).from - (*(ticket *)b).from;
return temp;
}

int judge(int cur, int n, int sum, int flag)
{
int i, temp;
for(temp=0,i=cur+flag; i<=n; ++i)
temp += route[i].price*route[i].people;
if(max > sum+temp) return 0;
else return 1;
}

int Traverse(int cur, int room, int n, int sum)
{
int temp, i, j;
if(cur > n)
{
max = max > sum ? max : sum;

/*    printf("max = %d sum = %d room = %d\n", max, sum, room);
for(i=1; i<=n; ++i)
printf("visit[%d] = %d\n", i, visit[i]);
printf("\n"); */
return 0;
}

for(i=1, temp=0; i<cur; ++i)
{
if(visit[i] == -1 && route[i].to <= route[cur].from)
{
temp += route[i].people;
visit[i] = cur;
}
}

if(room+temp - route[cur].people >= 0)
{
visit[cur] = -1;
if(judge(cur, n, sum, 0))
Traverse(cur+1, room+temp-route[cur].people, n, sum+route[cur].price*route[cur].people);
}

for(i=1; i<cur; ++i)
if(visit[i] == cur && route[i].to <= route[cur].from) visit[i] = -1;
visit[cur] = 0;
if(judge(cur, n, sum, 1))
Traverse(cur+1, room, n, sum);
return 0;
}

int main()
{
/*    freopen("input.txt", "r", stdin); */
int num, city, order, i, cnt;
while(scanf("%d%d%d", &num, &city, &order) != EOF)
{
if(!num && !city && !order) break;
memset(visit, 0, sizeof(visit));
for(i=1; i<=order; ++i)
{
scanf("%d%d%d", &route[i].from, &route[i].to, &route[i].people);
route[i].price = route[i].to - route[i].from;
}
qsort(route+1, order, sizeof(ticket), cmp);
/*        for(i=1; i<=order; i++) printf("%d %d\n", route[i].from, route[i].to); */
max = cnt = 0;
Traverse(1, num, order, cnt);
printf("%d\n", max);
}
return 0;
}