解題報告
題目來源：
PKU 3513 Let's Go to the Movies
分類：
樹形DP
原文：
Let's Go to the Movies
|
Time Limit: 1000MS
|
|
Memory Limit: 65536K
|
|
Total Submissions: 228
|
|
Accepted: 56
|
Description
A favorite
pastime for big families in Acmestan is going to the movies. It is quite common
to see a number of these multi-generation families going together to watch a
movie. Movie theaters in Acmestan have two types of tickets: A single ticket
is for exactly one person while a family ticket allows a parent and
their children to enter the theater. Needless to say, a family ticket is always
priced higher than a single ticket, sometimes as high as five times the price
of a single ticket.
It is quite
challenging for families to decide which ticket arrangement is most economical
to buy. For example, the family depicted in the figure on the right has four
ticket arrangements to choose from: Seven single tickets; Two family tickets;
One family ticket (for adam, bob, cindy) plus four
single tickets for the rest; Or, one family ticket (for bob and his
four children) plus single tickets for the remaining two.
Write a
program to determine which ticket arrangement has the least price. If there are
more than one such arrangement, print the arrangement that has the least number
of tickets.
Input
Your program
will be tested on one or more test cases. The first line of each test case
includes two positive integers (S and F) where S is the
price of a single ticket and F is the price of a family ticket. The
remaining lines of the test case are either the name of a person going by
him/herself, or of the form:
N1 N2 N3
… Nk
where N1
is the name of a parent, with N2… Nk being
his/her children. Names are all lower-case letters, and no longer than 1000
characters. No parent will be taking more than 1000 of their children to the
movies :-). Names are
unique, the name of a particular person will appear at most twice: Once as a
parent, and once as a child. There will be at least one person and at most
100,000 people in any test case.
The end of a
test case is identified by the beginning of the following test case (a line
made of two integers.) The end of the last test case is identified by two
zeros.
Output
For each
test case, write the result using the following format:
k. NS NF T
Where k is the test
case number (starting at 1), NS is the number of single tickets, NF is the
number of family tickets, and T is the total cost of tickets.
Sample Input
1
3
adam
bob cindy
bob
dima edie fairuz gary
1
2
john
paul
george
ringo
1
3
a
b c
0
0
Sample Output
1.
2 1 5
2.
4 0 4
3.
0 1 3
Source
Arab
and North Africa 2007
中文描述：
一個大家庭一起去電影院看電影，電影院有兩種票提供：個人票和家庭票。個人票只允許一個人進電影院看電影，而家庭票則可允許一個人帶上他的兒子或女兒一起去看電影。給出整個大家庭的家族樹，讓你算出整個大家庭一起去看電影的總費用以及買個人票和家庭票的數目。當存在有總費用相同的多種方案時，選取總票數最少的那個。
題目分析與算法模型
很顯然，題目給出的簡化版家譜是一棵樹（每個家庭只有一個父親或母親），每個節點有三種情況：買個人票、買家庭票以及因為父母買了家庭票而不用買票。接著，我們對每一種情況分別討論：
當某個節點買了個人票時，以這個節點為子樹的最優情況（也就是最少費用）是：他的每個孩子的最優情況加上自己買的個人票。
當某個節點買了家庭票是，他的孩子可以選擇買票，也可以選擇不買票。對于他的每個孩子，這個節點會選擇這個孩子買票時的最優情況和不買票的最優情況中的那個費用較低的那個（費用一樣，就選總票數最少的那個），最后再加上自己的家庭票。
當某個節點因為父母買了家庭票而自己不需要買票時，他的最優情況是：他的每個孩子買票時的最優情況的總和。
無論當前節點選取的是什么情況，也無論這個節點會選取他的孩子的哪種情況，但肯定的是，只要當前節點在某種情況下（個人票、家庭票、不買票）達到最優，他的孩子也必然是某種情況下的最優。也就是，當原問題最優時，子問題也最優，因此問題具有最優子結構，而且在求解過程中，會多次計算某個節點在某種情況下的最優值，因此問題求解過程中具有重疊子問題。所以說，該問題可以用DP來解決。
代碼：
#include <iostream>
#include <string>
#include <map>
#include <vector>
using namespace std;
const int MAX = 100005;
int single, family;
int a, b; //暫時記錄個人票和家庭票的價格
map<string, int> dic; //將名字與一數字進行映射
map<string, int>::iterator it; //迭代器
vector<int> sons[MAX]; //鄰接表，記錄某個節點的孩子
int people; //家庭中的人數
int notRoot[MAX];
char s[1005]; //暫時存儲輸入的姓名
struct Node
{
int singleNum, familyNum;
int minPrice;
};
//某個節點買票時的最優情況和不買票時的最優情況
Node minBuy[MAX], minNotBuy[MAX];
int isNumber (string s)
{
int i, ans;
ans = 0;
for (i=0; i<s.length(); i++)
{
if ( s[i] >= '0'
&& s[i] <= '9' )
ans = ans*10 +
(s[i]-'0');
else
return -1;
}
return ans;
}
void Initial ()
{
memset(notRoot, 0,
sizeof(notRoot));
people = 0;
memset(minBuy, -1,
sizeof(minBuy));
memset(minNotBuy, -1,
sizeof(minNotBuy));
dic.clear();
}
bool Input ()
{
//如果上個testcase已經將這次輸入的第一個變量讀入到a，就無需再讀入
if ( a == -1 )
scanf("%d",
&a);
scanf("%d", &b);
single = a;
family = b;
a = b = -1;
if ( single == 0 &&
family == 0 )
return false;
char ch;
int pIndex, sIndex;
string parent, son;
Initial ();
while (1)
{
//先將名字讀入字符串數組，在將其置于string， 這樣做是為了節省時間
scanf("%s",
&s);
parent = "";
parent.append(s);
a = isNumber(parent);
if ( a != -1 ) //讀入了下個testcase的數據
break;
it = dic.find(parent); //查找有無對應映射
if ( it == dic.end() )
{
dic[parent] = people;
sons[people].clear();
people++;
}
pIndex = dic[parent];
//讀取當前節點的孩子
ch = getchar();
while ( ch != '\n' )
{
scanf("%s",
&s);
son = "";
son.append(s); //把字符數組的內容傳給string
it = dic.find(son);
if ( it == dic.end()
)
{
dic[son] =
people;
sons[people].clear();
people++;
}
sIndex = dic[son];
sons[pIndex].push_back(sIndex);
notRoot[sIndex] = 1;
ch = getchar();
}
}
return true;
}
int getMinBuy (int); //計算買票時的最少費用
int getMinNotBuy (int); //計算不買票時的最少費用
int getMinBuy (int index)
{
if ( minBuy[index].minPrice !=
-1 )
return
minBuy[index].minPrice;
int i;
//當前節點買家庭票
int singleNum1, familyNum1,
price1;
singleNum1 = 0;
familyNum1 = 1;
price1 = family;
for (i=0;
i<sons[index].size(); i++)
{
//買票時的費用比不買票時的費用低，或者費用相同時，買票時所買的總票數少
if (
getMinBuy(sons[index][i]) < getMinNotBuy(sons[index][i])
|| (
getMinBuy(sons[index][i])==getMinNotBuy(sons[index][i])
&& minBuy[sons[index][i]].singleNum+
minBuy[sons[index][i]].familyNum
<=
minNotBuy[sons[index][i]].singleNum
+
minNotBuy[sons[index][i]].familyNum
) )
{
price1 +=
minBuy[sons[index][i]].minPrice;
singleNum1 +=
minBuy[sons[index][i]].singleNum;
familyNum1 +=
minBuy[sons[index][i]].familyNum;
}
else
{
price1 +=
minNotBuy[sons[index][i]].minPrice;
singleNum1 +=
minNotBuy[sons[index][i]].singleNum;
familyNum1 +=
minNotBuy[sons[index][i]].familyNum;
}
}
//當前節點買個人票
int singleNum2, familyNum2,
price2;
singleNum2 = 1;
familyNum2 = 0;
price2 = single;
for (i=0;
i<sons[index].size(); i++)
{
price2 +=
getMinBuy(sons[index][i]);
singleNum2 +=
minBuy[sons[index][i]].singleNum;
familyNum2 +=
minBuy[sons[index][i]].familyNum;
}
//決定當前節點買票時，是買個人票還是買家庭票
if ( price1 < price2 || (
price1 == price2 && singleNum1 +
familyNum1 <= singleNum2
+ familyNum2 ) )
{
minBuy[index].minPrice =
price1;
minBuy[index].singleNum =
singleNum1;
minBuy[index].familyNum =
familyNum1;
}
else
{
minBuy[index].minPrice =
price2;
minBuy[index].singleNum =
singleNum2;
minBuy[index].familyNum =
familyNum2;
}
return minBuy[index].minPrice;
}
int getMinNotBuy (int index)
{
if ( minNotBuy[index].minPrice
!= -1 )
return
minNotBuy[index].minPrice;
int i, singleNum, familyNum,
price;
singleNum = familyNum = 0;
price = 0;
//取每個孩子買票的最優情況
for (i=0;
i<sons[index].size(); i++)
{
price +=
getMinBuy(sons[index][i]);
singleNum +=
minBuy[sons[index][i]].singleNum;
familyNum +=
minBuy[sons[index][i]].familyNum;
}
minNotBuy[index].minPrice =
price;
minNotBuy[index].singleNum =
singleNum;
minNotBuy[index].familyNum =
familyNum;
return
minNotBuy[index].minPrice;
}
void Solve ()
{
int i, price, singleNum,
familyNum;
price = singleNum = familyNum =
0;
for (i=0; i<people; i++)
{
if ( ! notRoot[i] )
{
price +=
getMinBuy(i);
singleNum +=
minBuy[i].singleNum;
familyNum +=
minBuy[i].familyNum;
}
}
printf("%d %d %d\n",
singleNum, familyNum, price);
}
int main ()
{
int i = 0;
a = b = -1;
while ( Input() )
{
printf("%d. ",
++i);
Solve ();
}
return 0;
}
心得：
本題有兩個考察的地方，一是是否能對簡單的樹形DP模型進行構建，二是是否有比較強的實際編程能力。第一點我不想再重復，前面講的也比較詳細。做了這題，感覺收獲最大的就是學了不少的編程的小技巧。比如處理輸入輸出（本題的輸入讓人有些頭疼）、利用STL中的map把字符串和整數映射起來（這個很有用）、利用vector建樹、為了節省時間先把字符串讀入到字符數組，再把內容傳給string等等。雖然這些小技巧看起來有些“微不足道”，但在平時做題或者比賽時，如果不熟練掌握這些小技巧，往往會在關鍵時刻阻礙你解題的步伐。算法的理論知識是可以從書本上學到的，但那些編程的技巧卻只能從平時做題的積累中才能慢慢掌握的。其中，我感覺，使用STL可以大大減少編程的復雜程度。雖然對于那些剛接觸算法的同學來說，我并不推薦使用STL，因為這樣會屏蔽掉許多底層的原理。但在比賽時，使用STL還是可以節約不少時間與精力的。STL中，比較常用的有string、vector、map、priority_queue等等，已經有一些做題經驗的同學可以在平時順帶的看一下有關STL的內容（推薦一個網站：http://www.cplusplus.com/，里面幾乎包含所有關于C++函數以及STL的參考資料，大部分函數都帶有簡明的代碼樣例）。