TopCoder SRM 579

div.1

T1

题意

编辑器由三部分组成：结果窗口，文本缓冲区和撤消历史记录。
Bob可能会输入一个小写字母。该字母附加到文本缓冲区。然后将新文本缓冲区添加为撤消历史记录的新元素。
Bob可以使用两次鼠标单击将任何条目从撤消历史记录恢复到文本缓冲区。此操作不会修改撤消历史记录。
返回Bob需要将所有给定行打印到结果窗口中的最小按钮按下次数

思路

模拟每个步骤，用set保存htory字符串。

#include 
using namespace std;

class UndoHistory {
public:
    int minPresses( vector <string> lines ) ;
};
int UndoHistory::minPresses(vector <string> a) {
	int ans=0,j,lh,ls,i;
	string s="";
	set<string> h;
	h.insert("");
	for(i=0;i<a.size();i++)
	{
		ls=s.size();
		lh=0;
		for(j=a[i].size();j>=1;j--)
		{
			if(!h.insert(a[i].substr(0,j)).second)
			{
				lh=j;
				break;
			}
		}
		if(lh<ls+2&&s==a[i].substr(0,ls))
		{
			ans+=a[i].size()-ls+1;
			for(j=ls+1;j<=a[i].size();j++)
				h.insert(a[i].substr(0,j));
		}
		else if(lh>0)
		{
			ans+=a[i].size()-lh+3;
			for(j=lh+1;j<=a[i].size();j++)
				h.insert(a[i].substr(0,j));
		}
		else
		{
			ans+=a[i].size()+3;
			for(j=1;j<=a[i].size();j++)
				h.insert(a[i].substr(0,j));
		}
		s=a[i];
	}
	return ans;
}

T2

题意

用骰子玩石头剪刀布，n个一模一样的骰子都有外挂，获得三个手势中的每一个的概率不一定是均匀的。
赢了得3分，平局1分，输了0分
您的任务是找到此游戏的策略，以最大化您获得的预期总点数

思路

E(x)=∑x∈AScore(x)×P(x)
只要考虑投了m轮得到(r,p,s)的概率和分数就好了。
概率可以这样DP。
ft,i,r,p,s表示考虑前t个骰子，i没被丢出来，出了(r,p,s)的概率。

#include 
using namespace std;
double d[100][5],f[51][51][51][51];
class RockPaperScissors {
public:
    double bestScore( vector <int> rockProb, vector <int> paperProb, vector <int> scissorsProb ) ;
};

double RockPaperScissors::bestScore(vector <int> a, vector <int> b, vector <int> c) {
	int n,i,j,k,l,t,x;
	double ans=0,s;
	n=a.size();
	for(i=1;i<=n;i++)
	{
		d[i][1]=1.0*a[i-1]/300;
		d[i][2]=1.0*b[i-1]/300;
		d[i][3]=1.0*c[i-1]/300;
	}
	for(i=1;i<=n;i++) f[i][0][0][0]=1;
	for(t=1;t<=n;t++)
		for(i=t;i>=0;i--)
			for(j=0;j<=i;j++)
				for(k=0;k+j<=i;k++)
				{
					x=i-j-k;
					s=1.0*i/t;
					for(l=1;l<=n;l++)
					{
						f[l][j][k][x]=1.0*f[l][j][k][x]*(1-s);
						if(l==t) continue;
						if(j>0) f[l][j][k][x]=f[l][j][k][x]+1.0*f[l][j-1][k][x]*s*d[t][1];
						if(k>0) f[l][j][k][x]=f[l][j][k][x]+1.0*f[l][j][k-1][x]*s*d[t][2];
						if(x>0) f[l][j][k][x]=f[l][j][k][x]+1.0*f[l][j][k][x-1]*s*d[t][3];
					}
				}
				
	for(i=0;i<n;i++)
		for(j=0;j+i<n;j++)
			for(k=0;i+j+k<n;k++)
			{
				x=i+j+k;
				double x1=0,x2=0,x3=0;
				for(l=1;l<=n;l++)
				{
					s=f[l][i][j][k];
					x1+=1.0*s*d[l][1];
					x2+=1.0*s*d[l][2];
					x3+=1.0*s*d[l][3];
				}
				x1=1.0*x1/(n-x);
				x2=1.0*x2/(n-x);
				x3=1.0*x3/(n-x);
				ans=ans+max(max(x1+x3*3,x2+x1*3),x3+x2*3);
			}
	return ans;
}

div.2

T3

题意

有一些圆 ，可以按任意顺序排列在地面上，返回最远两个点的距离的最小值

思路

以广度优先或者最小损耗的方式搜索解空间，在搜索过程中，不断舍弃非最优解。
一般来说，分支限界法的实现，需要一个有限队列，每次，弹出一个扩展节点，然后基于该扩展节点再搜索，不断加入可能的扩展节点入队，直至队列为空。
但是在此题中，关于圆的排列，缺乏明确的条件在广度优先搜索中淘汰非最优节点。所以，退化为递归+剪枝。

#include 
using namespace std;
struct node
{
	double x;
	int r;
};
bool vis[100010];
vector<node> a;
double ans;
class MarblePositioning {
public:
    double totalWidth( vector <int> radius ) ;
};
double get_len()
{
	if(a.size()==0) return 0;
	return a[a.size()-1].x-a[0].x;
}
double get(node add)
{  
	double x=0,t;
	for(int i=0;i<a.size();i++)
	{
		t=a[i].x+2*sqrt(a[i].r*add.r);
		if(t>x) x=t;
	}
    return x;       
}  
void sol(vector<node> s)
{
	if(get_len()>ans) return;
	if(s.size()==a.size())	
	{
		double len=get_len();
		if(len<ans) ans=len;
		return;
	}
	for(int i=0;i<s.size();i++)
	{
		if(vis[i]) continue;
		s[i].x=get(s[i]);
		a.push_back(s[i]);
		vis[i]=1;
		sol(s);
		a.pop_back();
		vis[i]=0;
		s[i].x=0;
	}
}
double MarblePositioning::totalWidth(vector <int> r) {
	ans=INT_MAX;
	vector<node> s(r.size());
	memset(vis,0,sizeof(vis));
	for(int i=0;i<r.size();i++)
	{
		s[i].r=r[i];
		s[i].x=0;
	}
	sol(s);
    return ans;  
}