Topcoder Open 3B (TCO 3B)

最新推荐文章于 2018-11-05 19:16:46 发布

weixin_30273931

最新推荐文章于 2018-11-05 19:16:46 发布

阅读量132

点赞数

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/absi2011/p/9342692.html

本文探讨两道算法题目，一是判断给定矩阵是否能从无限区域中切割出来，并找出最小覆盖边长；二是计算多个实验者完成实验的期望等待时间，采用比特掩码优化递归算法。

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(2ⁿ*n²)的算法,正解是O(2ⁿ*n)的

我们首先反向思考,4s,n<=20?

一看就觉得有问题,所以思考指数级做法

首先想到了一个做法

我们用bitmask表示每个学生走没走

那么我们就求到这个状态的概率以及前面期望消耗时间

然后我们暴力转移给每一个后继,复杂度O(3ⁿ)

但是我们如果不暴力转移呢?

我们思考,把每个点拆成n个点

每个点(i,j)表示bitmask为i,当前在转移j

那么就只有两个后继了:转移还是不转移(如果转移过只有一个:不转移)

这样的话,我们会产生一个环,这时候我们需要特殊处理一下这个环

这个环上,n-->1会导致答案+1,需要处理

另外需要做一些数学计算.....

所以我们就需要这么处理

我们对于每一个i,我们考虑它的j最终可能会落在哪里

这个我们可以思考一下,落在本身的位置是p_j/q_j,下一个是(1-p_j/q_j)*(p_j+1/q_j+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

转载于:https://www.cnblogs.com/absi2011/p/9342692.html