250
在一个无限的区域里面,有n*n(n>=1)的地方是#,别的是'.'
现在给你一个矩阵,问它是否可能是这个区域的一部分
如果可能,返回最小的n
如果不可能返回0
数据范围50*50
500
时限4s
现在有n个人在做实验
每个人每一秒有p/q的概率做完离开
而你,作为他们的老师,需要等他们都做完实验再离开
问你期望什么时候离开
n<=20,1<=p<=q<=1e9
1000
没看
===========================
250
首先你得是个矩形吧....
判定矩形,求它的最左最右最上最下,看是否全部填充
然后考虑一下边界情况..
情况有点多...
大概就是如果它在边上,那么就可以额外填充字符让它变成一个矩形
还要考虑下没找到的情况..返回1
500
这题真的费劲,而且得到的还不是正解,是O(2n*n2)的算法,正解是O(2n*n)的
我们首先反向思考,4s,n<=20?
一看就觉得有问题,所以思考指数级做法
首先想到了一个做法
我们用bitmask表示每个学生走没走
那么我们就求 到这个状态的概率以及前面期望消耗时间
然后我们暴力转移给每一个后继,复杂度O(3n)
但是我们如果不暴力转移呢?
我们思考,把每个点拆成n个点
每个点(i,j)表示bitmask为i,当前在转移j
那么就只有两个后继了:转移还是不转移(如果转移过只有一个:不转移)
这样的话,我们会产生一个环,这时候我们需要特殊处理一下这个环
这个环上,n-->1会导致答案+1,需要处理
另外需要做一些数学计算.....
所以我们就需要这么处理
我们对于每一个i,我们考虑它的j最终可能会落在哪里
这个我们可以思考一下,落在本身的位置是pj/qj,下一个是(1-pj/qj)*(pj+1/qj+1)
这样下去,回到自己也有一个概率,我们就把剩下的概率再按上面的比例分摊一下
例如Sample 1
{1,2},{2,4}
其实就是两个1/2
落在本身是1/2,下一个是1/4,回到自己是1/4
那么分摊一下就是
2/3 和 1/3
这样我们就可以求概率了,答案也是相似的求法,但是一定要注意只有n-->1这一段路是要答案+1,别的都不要
250
#include<set>
#include<map>
#include<list>
#include<queue>
#include<stack>
#include<string>
#include<time.h>
#include<math.h>
#include<memory>
#include<vector>
#include<bitset>
#include<fstream>
#include<stdio.h>
#include<utility>
#include<string.h>
#include<iostream>
#include<stdlib.h>
#include<algorithm>
using namespace std;
struct SquareCutout
{
int verify(vector <string> a)
{
int n=a.size();
int m=a[0].length();
int i,j;
int min_i=n,min_j=m,max_i=-1,max_j=-1;
for (i=0;i<n;i++)
{
for (j=0;j<m;j++)
{
if (a[i][j]=='#')
{
min_i=min(i,min_i);
min_j=min(j,min_j);
max_i=max(i,max_i);
max_j=max(j,max_j);
}
}
}
if (max_i==-1)
{
return 1;
}
for (i=min_i;i<=max_i;i++)
{
for (j=min_j;j<=max_j;j++)
{
if (a[i][j]!='#')
{
return 0;
}
}
}
if (max_i-min_i==max_j-min_j)
{
return max_i-min_i+1;
}
if ((max_i==n-1)||(min_i==0))
{
if (max_i-min_i<max_j-min_j)
{
return max_j-min_j+1;
}
}
if ((max_j==m-1)||(min_j==0))
{
if (max_i-min_i>max_j-min_j)
{
return max_i-min_i+1;
}
}
return 0;
}
};
#ifdef absi2011
int main()
{
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
return 0;
}
#endif
500
#include<set>
#include<map>
#include<list>
#include<queue>
#include<stack>
#include<string>
#include<time.h>
#include<math.h>
#include<memory>
#include<vector>
#include<bitset>
#include<fstream>
#include<stdio.h>
#include<utility>
#include<string.h>
#include<iostream>
#include<stdlib.h>
#include<algorithm>
using namespace std;
float ans[1<<20][20];
float pro[1<<20][20];
double num[25];
double fact[25];
double fact_p[25];
double calc(int n)
{
int i;
pro[(1<<n)-1][0]=1;
for (i=(1<<n)-1;i>0;i--)
{
double p=1;
int j;
for (j=0;j<n;j++)
{
if ((1<<j)&i)
{
p*=(1-num[j]);
}
}
for (j=0;j<n;j++)
{
fact[j]=0;
fact_p[j]=0;
}
for (j=0;j<n;j++)
{
int k;
int flag=2;
double p2=1/(1-p);
for (k=j;;k++)
{
if (k==n)
{
k=0;
}
if (k==j) flag--;
if (flag==0) break;
//From j to k?
if ((1<<k)&i)
{
fact[k]+=p2*num[k]*pro[i][j];
fact_p[k]+=p2*num[k]*ans[i][j];
if (k<j)
{
fact_p[k]+=p2*num[k]*pro[i][j];
}
p2*=(1-num[k]);
}
}
}
p=1/(1-p);
for (j=0;j<n;j++)
{
if ((1<<j)&i)
{
if (j!=n-1)
{
ans[i^(1<<j)][j+1]+=(p-1)*fact[j]+fact_p[j];
pro[i^(1<<j)][j+1]+=fact[j];
}
else if ((1<<j)==i)
{
ans[i^(1<<j)][0]+=(p-1)*fact[j]+fact_p[j];
pro[i^(1<<j)][0]+=fact[j];
}
else
{
ans[i^(1<<j)][0]+=p*fact[j]+fact_p[j];
pro[i^(1<<j)][0]+=fact[j];
}
}
}
}
double sum=0;
for (i=0;i<n;i++)
{
sum+=ans[0][i];
}
return sum+1;
}
struct TestProctoring
{
double expectedTime(vector <int> p, vector <int> q)
{
int n=p.size();
int i;
for (i=0;i<n;i++)
{
num[i]=p[i]*1.0/q[i];
}
return calc(n);
}
};
#ifdef absi2011
int main()
{
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
int a[]={3,1,2,4,2,5};
int b[]={3,1,2,4,2,5};
vector<int> pp;
int i;
for (i=0;i<sizeof(a)/sizeof(int);i++)
{
pp.push_back(a[i]);
}
vector<int> qq;
for (i=0;i<sizeof(a)/sizeof(int);i++)
{
qq.push_back(b[i]);
}
TestProctoring x;
cout<<x.expectedTime(pp,qq);
return 0;
}
#endif