最近想提高一下编程能力，参加了腾讯编程马拉松，结果五道题却制作出来了一道，有点受打击，于是就在HDOJ上找题练一下，随便就找到了HDOJ2901，于是开始了此文。（一开始就做这个似乎有点难的题，我开始怀疑自己是否有点好高骛远了）
题目就不多说了，见http://acm.hdu.edu.cn/showproblem.php?pid=2901
大意是要从接收到的字符串中找出最可能的发送字符串，已知的是发送a/b接受a/b的概率矩阵和发送a/b再次发送a/b的概率
题目的举例就是以此列举所有的可能性，然后比较每一种可能性的概率，取最大者。
所以一开始，我的思路很单纯：收发有a种字符，接受字符串长度w最大为300，所以最终的可能性有aw种可能性（其实对于题目的极限来说30300一定是难以承受的，也不知道最终会怎么去判断是否AC），而我就开始很单纯地取用pow（a,w）函数来作为循环结束的条件，结果总是超时。
我最开始的代码如下：
#include <fstream>
#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <map>
//#include <algorithm>
//#define DEBUG
using namespace std;
int main(int argc, int * argv[])
{
//fstream cin("aaa.txt");
int n,a,i,j,num_case;
char c;
float d;
string s;
map<char,int> map_ch;
cin>>n;
while(n--)
{
cin >> a; //读入字符种类数
char ch[30];//vector<char> ch(a);
for(i=0;i<a;i++)
{
cin>>c;
ch[i] = c;
map_ch[c] = i;
//cout<<ch[i]<<endl;
}
//读入接受错误概率和字符继承概率矩阵
//注意下面这一行：vector<int后两个">"之间要有空格！否则会被认为是重载">>"。
float REP[30][30];//vector<vector<float> > REP(a, vector<float>(a)); //Receiving Error Probabilities
for(i=0;i<a;i++)
for(j=0;j<a;j++)
{
cin>>d;
REP[i][j] = d;
//cout<<REP[i][j]<<" ";
}
float CSP[30][30];//vector<vector<float> > CSP(a, vector<float>(a)); //Character Succession Probabilities
for(i=0;i<a;i++)
for(j=0;j<a;j++)
{
cin>>d;
CSP[i][j] = d;
//cout<<CSP[i][j]<<" ";
}
//读入测试案例
cin>>num_case;
for(j=0;j<num_case;j++)
{
cin>>s;
int s_length = s.length();
// 把输入的数据转换成0~a-1 比如ab转换成01 bb转换成11
vector<int> s_a(s_length);
for(i=0;i<s_length;i++)
for(int k=0;k<a;k++)
if(ch[k] == s[i]) s_a[i] =k;
//s_a[i] = map_ch[s[i]];
#ifdef DEBUG
cout<<"s_a : ";
for(i=0;i<s_length;i++)
cout<<s_a[i];
cout<<endl;
#endif
float max_p = 0.0; //最大概率
vector<int>MaxLikely(s_length); //最终结果
int max_maybes = pow(a,s_length);
for(i=0;i<max_maybes;i++) //一共有pow(a,s_length)种可能
{
vector<int>s_maybe(s_length); //可能的字符串
int n_maybes = i;
for(intk=0;k<s_length;k++) //将i转化成a进制数存在s_maybe中
{
s_maybe[k] = n_maybes % a;
n_maybes /= a;
}
//reverse(s_maybe.begin(),s_maybe.end());
#ifdef DEBUG
cout<<"s_maybe : ";
for(k=0;k<s_length;k++)
cout<<s_maybe[k];
cout<<endl;
#endif
// 计算概率
float liklyhood = 1;
for(k=0;k<s_length;k++)
{
liklyhood *=REP[s_maybe[k]][s_a[k]];
#ifdef DEBUG
cout<<"REP:"<<s_maybe[k]<<s_a[k]<<""<<endl;
#endif
}
for(k=0;k<s_length-1;k++)
{
liklyhood *=CSP[s_maybe[k]][s_maybe[k+1]];
#ifdef DEBUG
cout<<"CSP:"<<s_maybe[k]<<s_a[k]<<""<<endl;
#endif
}
#ifdef DEBUG
cout<<"likelyhood ="<<liklyhood<<endl;
#endif
if(liklyhood > max_p)
{
max_p = liklyhood;
for(k=0;k<s_length;k++)
MaxLikely[k] = s_maybe[k];
//MaxLikely = s_maybe;
}
}
//reverse(MaxLikely.begin(),MaxLikely.end());
for(i=s_length-1;i>=0;i--)
cout<<ch[MaxLikely[i]];
cout<<endl;
}
}
return 0;
}
代码的质量不敢说，只能说思路还是比较清晰的，而且看了曾宗根的书也用了一些数据结构，算是练个手吧，当然结果还是比较悲剧的。
后来在一位大神（OJ名”给数据跪了”，在此对您表示由衷的感谢）的帮助下，看懂了他的代码的思路，并开始用他的思路去思考问题。
他的思路是可以说是分级讨论问题，因为从后往前来看，需要找出的字符串的最后一个(第w个)字符是什么只取决于它前面一个(第w-1个)字符是什么，而第w-1个字符是什么取决于第w-2个字符……如此就形成了一个级联的问题。
首先已知REP[a][b] （Receiving Error Probabilities）即接收错误概率矩阵——发送a接收b的概率
和CSP[a][b] （CharacterSuccession Probabilities）即字符后继概率矩阵——发送a在发送b的概率
程序大致思路如下，假设只接收到一个字符s[0]，很容易根据REP[a][s[0]]、REP[b][s[0]]来判断发送的是a还是b，如果此时再接收到一个字符s[1]，就要进行讨论了
假设接收到的s[1]对应于发送a，对于前一个字符对应于a还是b，进行如下讨论：
如果是a，其概率为REP[a][s[0]]×CSP[a][a]：发送a接收s[0]的概率乘以发送a再发送a的概率
如果是b，其概率为REP[b][s[0]]×CSP[b][a]：发送b接收s[0]的概率乘以发送b再发送a的概率
这时就可以根据以上乘积的大小来判断出当s[1]对应于发送a时s[0]对应于发送什么了，然后可以得到s[1]对应于发送a的概率为
max{REP[a][s[0]]×CSP[a][a]，REP[a][s[0]]×CSP[a][a]}×REP[a/b][s[1]]
（其中a/b对于与乘积的较大者）
同理，可得到s[1]对应于发送b的概率为
max{REP[a][s[0]]×CSP[a][b]，REP[a][s[0]]×CSP[a][b]}×REP[a/b][s[1]]
（其中a/b对于与乘积的较大者）
并且当s[1]对应于发送a时s[0]对应于发送以上max函数中的较大者
如果继续接收到第三个字符，同样可以进行以上假设：
假设接收到的s[2]对应于发送a，对于前一个字符对应于a还是b，进行如下讨论：
如果是a，其概率为P(第二个字符是a的概率)×CSP[a][a]：第二个字符是a的概率乘以发送a再发送a的概率
如果是b，其概率为P(第二个字符是b的概率)×CSP[b][a]：第二个字符是b的概率乘以发送b再发送a的概率
而其中的P(第二个字符是a的概率)已经在前文中求的，所以可以用循环实现。
本算法的复杂度为a×a×w，远比aw小很多。（其中a是字符种类，w是字符串的长度）
我最终的代码如下：
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <map>
#include <vector>
#include <string>
using namespace std;
int main(int argc, char *argv[])
{
fstreamcin("aaa.txt");
intn,a,i,j,num_case;
map<char,int>MAP_CH;
charc;
doubled;
chars[300];//string s;
cin>>n;
while(n--)
{
cin>> a; //读入字符种类数
charch[30];//vector<char> ch(a);
for(i=0;i<a;i++)
{
cin>>c;
ch[i]= c;
MAP_CH[c]= i;
//cout<<ch[i]<<endl;
}
//读入接受错误概率和字符继承概率矩阵
//注意下面这一行：vector<int后两个">"之间要有空格！否则会被认为是重载">>"。
doubleREP[30][30];//vector<vector<double> > REP(a, vector<double>(a)); //Receiving Error Probabilities
for(i=0;i<a;i++)
for(j=0;j<a;j++)
{
cin>>d;
REP[i][j]= d;
//cout<<REP[i][j]<<"";
}
doubleCSP[30][30];//vector<vector<double> > CSP(a, vector<double>(a)); //Character Succession Probabilities
for(i=0;i<a;i++)
for(j=0;j<a;j++)
{
cin>>d;
CSP[i][j]= d*10.0;
//cout<<CSP[i][j]<<"";
}
//读入测试案例
cin>>num_case;
while(num_case--)
{
cin>>s;
ints_length = strlen(s);//s.length();
vector<vector<double> > gl(s_length, vector<double>(a));
vector<vector<char> > answer(s_length, vector<char>(a));
for(i=0;i<a;i++)
gl[0][i] =REP[MAP_CH[ch[i]]][MAP_CH[s[0]]];
//cout<<gl[0][0]<<gl[0][1]<<endl;
for(int k=1; k<s_length;k++)
for(i=0;i<a;i++)
{
char c_last = ch[i]; //假设第k个字符是ch【i】
// 找出假设 c_last后的前一个字符（只可能有a种，对应概率为gl【k-1】【0~a-1】）的最大可能概率
double temp = 0;
for(j=0;j<a;j++)
{
if(temp< gl[k-1][MAP_CH[ch[j]]] * CSP[MAP_CH[ch[j]]][MAP_CH[c_last]])
{
temp = gl[k-1][MAP_CH[ch[j]]] * CSP[MAP_CH[ch[j]]][MAP_CH[c_last]];
answer[k][MAP_CH[c_last]] = ch[j]; //保存第k个字符是ch【i】时对应的第k-1个字符最大的可能的值
//cout<<answer[k][MAP_CH[c_last]]<<endl;
}
}
gl[k][MAP_CH[c_last]] =temp * REP[MAP_CH[c_last]][MAP_CH[s[k]]];
}
double temp = 0;
char ans_ch;
for(i=0;i<a;i++)
{
if(temp < gl[s_length-1][MAP_CH[ch[i]]])
{
temp =gl[s_length-1][MAP_CH[ch[i]]];
ans_ch =ch[i];//最后的一个最大概率字符
}
}
vector<char>s_answer(s_length);
s_answer[s_length-1]=ans_ch;
char ch_out = ans_ch;
for(i=s_length-2;i>=0;i--)
{ch_out = answer[i+1][MAP_CH[ch_out]];
s_answer[i]=ch_out; }
for(i=0;i<s_length;i++)
cout<<s_answer[i];
cout<<endl;
}
}
return0;
}
思路看懂后，很快就可以写程序了，但是有个比较纠结的问题，我发现读入CSP[][]矩阵（也就是发送字符后继概率矩阵）的时候，如果不保存为它的十倍（即*=10.0），提交的结果就是WrongAnswer，否则可以AC了。
这个问题困扰了我很久，自己的程序都快被改的乱七八糟了，百思不得其解，有点怀疑网站测试时的问题了，希望好心人给点提示。
再次感谢”给数据跪了”对我的启发。
扫一扫
492
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
