初探随机（持续更新）

随机乱搞能派上用场的大多数情况，都是数据较小，较复杂的DP问题，这个定义有点窄，其实很多需要递推、枚举的问题都可以考虑随机化，当然，这一类算法实在走投无路的情况下才能使用，因为 实在是太玄学了。

加一个同期随机大师的博客：随机化算法在NOIP中的应用

1.用随机更优解来优化随机点的方法

这一类方法，大意是先随机多个可能的解，对于每一个解，用一定范围内的其他值来更新它，这个范围逐渐缩小。

2926 -- 【模拟试题】教主泡嫦娥

Description

【问题背景】

　　2012年12月21日下午3点14分35秒，全世界各国的总统以及领导人都已经汇聚在中国的方舟上。

　　但也有很多百姓平民想搭乘方舟，毕竟他们不想就这么离开世界，所以他们决定要么登上方舟，要么毁掉方舟。

　　LHX教主听说了这件事之后，果断扔掉了手中的船票。在地球即将毁灭的那一霎那，教主自制了一个小型火箭，奔向了月球……

　　教主登上月球之后才发现，他的女朋友忘记带到月球了，为此他哭了一个月。

　　但细心的教主立马想起了小学学过的一篇课文，叫做《嫦娥奔月》，于是教主决定，让嫦娥做自己的新任女友。

【问题描述】

　　教主拿出他最新研制的LHX(Let's be Happy Xixi*^__^*)卫星定位系统，轻松地定位到了广寒宫的位置。

　　见到嫦娥之后，教主用温柔而犀利的目光瞬间迷倒了嫦娥，但嫦娥也想考验一下教主。

　　嫦娥对教主说：“看到那边的环形山了么？你从上面那个环走一圈我就答应你～”

　　教主用LHX卫星定位系统查看了环形山的地形，环形山上一共有N个可以识别的落脚点，以顺时针1~N编号。每个落脚点都有一个海拔，相邻的落脚点海拔不同（第1个和第N个相邻）。

　　教主可以选择从任意一个落脚点开始，顺时针或者逆时针走，每次走到一个相邻的落脚点，并且最后回到这个落脚点。

　　教主在任意时刻，都会有“上升”、“下降”两种状态的其中一种。

　　当教主从第i个落脚点，走到第j个落脚点的时候（i和j相邻）

　　j的海拔高于i的海拔：如果教主处于上升状态，教主需要耗费两段高度差的绝对值的体力；否则耗费高度差平方的体力。

　　j的海拔低于i的海拔：如果教主处于下降状态，教主需要耗费两段高度差的绝对值的体力；否则耗费高度差平方的体力。

　　当然，教主可以在到达一个落脚点的时候，选择切换自己的状态（上升→下降，下降→上升），每次切换需要耗费M点的体力。在起点的时候，教主可以自行选择状态并且不算切换状态，也就是说刚开始教主可以选择任意状态并且不耗费体力。

　　教主希望花费最少的体力，让嫦娥成为自己的女朋友。

Input

　　输入的第一行为两个正整数N与M，即落脚点的个数与切换状态所消耗的体力。

　　接下来一行包含空格隔开的N个正整数，表示了每个落脚点的高度，题目保证了相邻落脚点高度不相同。

Output

　　输出仅包含一个正整数，即教主走一圈所需消耗的最小体力值。

　　注意：C++选手建议使用cout输出long long类型整数。

Sample Input

6 7

4 2 6 2 5 6

Sample Output

27

Hint

【样例解释】

　　从第3个落脚点开始以下降状态向前走，并在第4个落脚点时切换为上升状态。这样共耗费4 +(7)+3+1+2^2+2^2+4=27点体力。

【数据范围】

　　对于10%的数据，N ≤ 10；

　　对于30%的数据，N ≤ 100，a[i] ≤ 1000；

　　对于50%的数据，N ≤ 1000，a[i] ≤ 100000；

　　对于100%的数据，N ≤ 10000，a[i] ≤ 1000000，M ≤ 1000000000；

可以很简单地看出化环为链，枚举起点的暴力DP方法，方程也是显而易见的，这里不多做赘述。

但是数据范围不允许这种O(n*n)的算法AC。

可以注意到，这个算法的缓慢之处在于枚举起点。

怎么加快这个“枚举”呢？

我请教了同期随机化大神，这个枚举可通过以下随机化方案解决：

先随机20个起点，对于每个随机的起点，进行多（30+）次优化，所谓优化，就是以这个起点为中心，左右随机其他的点，以这个“其他的点”来优化当前“圆心”，随着时间的推移，优化的范围逐渐减小。

具体代码是这样的：

now=tp[i]+sin((double)(rand()%10000/10000))*T;

（其实就是斜边*正弦=直角边）

这里的T就是长度，T随着每一轮优化减小（T*=0.x）。

这样就能快速覆盖整个数列，并且准确度较高，速度较快地完成对起点的枚举。

代码如下。

#include<iostream>

#include<cstdio>

#include<cstring>

#include<algorithm>

#include<cstdlib>

#include<cmath>

#include<ctime>

using namespace std;

typedef long long ll;

inline ll read()

{

    ll bj=1ll;

    char ch=getchar();

    while(ch<'0'||ch>'9')

    {

        if(ch=='-')bj=-1ll;

        ch=getchar();

    }

    ll ret=0ll;

    while(ch>='0'&&ch<='9')ret=ret*10ll+ch-'0',ch=getchar();

    return ret*bj;

}

ll a[10001*2]={0},f[30001][2]={0},n,m,minn=1e100,b[30001]={0},cnt=0,tp[105]={0},note[100004]={0},now;

double T;

ll square(ll x){return x*x;}

ll DP(ll st)

{

    if(note[st])return note[st];

    cnt=0;

    for(ll i=st;i<=st+n;i++)b[++cnt]=a[i];

    f[1][1]=f[1][0]=0;//1:up   0:down

    for(ll i=2;i<=n+1;i++)

    {

        if(b[i]>b[i-1])

        {

            f[i][1]=min(f[i-1][0]+m+b[i]-b[i-1],f[i-1][1]+b[i]-b[i-1]);

            f[i][0]=min(f[i-1][1]+m+square(b[i]-b[i-1]),f[i-1][0]+square(b[i]-b[i-1]));

        }

        else

        {

            f[i][0]=min(f[i-1][1]+m+b[i-1]-b[i],f[i-1][0]+b[i-1]-b[i]);

            f[i][1]=min(f[i-1][0]+m+square(b[i]-b[i-1]),f[i-1][1]+square(b[i]-b[i-1]));

        }

    }

    return note[st]=min(f[n+1][1],f[n+1][0]);

}

int main()

{

    srand(time(NULL));

    n=read();m=read();

    for(ll i=1;i<=n;i++)a[i+n]=a[i]=read();

    for(int i=1;i<=20;i++)tp[i]=rand()%n+1;

    T=n;

    while(T>=1)

    {

        for(int i=1;i<=20;i++)

        {

            for(int j=1;j<=30;j++)

            {

                now=tp[i]+sin((double)(rand()%10000)/10000)*T;

                if(now<=0||now>n||DP(now)>=DP(tp[i]))continue;

                tp[i]=now;

            }

        }

        T*=0.5;

    }

    for(int i=1;i<=20;i++)minn=min(minn,note[tp[i]]);

    printf("%lld",minn);

return 0;

}

再来一题。

2684 -- 【CEOI2004】锯木厂选址

Description

　　从山顶上到山底下沿着一条直线种植了n棵老树。当地的政府决定把他们砍下来。为了不浪费任何一棵木材，树被砍倒后要运送到锯木厂。

　　木材只能按照一个方向运输：朝山下运。山脚下有一个锯木厂。另外两个锯木厂将新修建在山路上。你必须决定在哪里修建两个锯木厂，使得传输的费用总和最小。假定运输每公斤木材每米需要一分钱。

　　你的任务是编写一个程序，从输入文件中读入树的个数和他们的重量与位置，计算最小运输费用。

Input

　　输入的第一行为一个正整数n——树的个数（2≤n≤20000）。树从山顶到山脚按照1，2……n标号。接下来n行，每行有两个正整数（用空格分开）。第i+1行含有：wi——第i棵树的重量（公斤为单位）和 di——第i棵树和第i+1棵树之间的距离，1≤wi≤10000，0≤di≤10000。最后一个数dn，表示第n棵树到山脚的锯木厂的距离。保证所有树运到山脚的锯木厂所需要的费用小于2000000000分。

Output

　　输出只有一行一个数：最小的运输费用。

Sample Input

9

1 2

2 1

3 3

1 1

3 2

1 6

2 1

1 2

1 1

Sample Output

26

这道题的思想也是先随机一堆可能的解，随机更优解，来覆盖区间。

但是这个题用sin莫名不能AC，随即一个小数却可以，比较玄学。

#include<iostream>

#include<cstdio>

#include<cstring>

#include<algorithm>

#include<cstdlib>

#include<ctime>

#include<cmath>

#define PI 3.1415926535

using namespace std;

typedef long long ll;

inline ll read()

{

    ll bj=1ll;

    char ch=getchar();

    while(ch<'0'||ch>'9')

    {

        if(ch=='-')bj=-1ll;

        ch=getchar();

    }

    ll ret=0ll;

    while(ch>='0'&&ch<='9')ret=ret*10ll+ch-'0',ch=getchar();

    return ret*bj;

}

ll n,tp[6005][3]={0},d[100005]={0},sw[100005]={0},sd[100005]={0},cost[100005]={0};

struct node

{

    ll pos,val;

}a[20005];

void init()

{

    srand(time(NULL));

    n=read();

    for(ll i=1;i<=n;i++)

    {

        a[i].val=read();

        d[i]=read();

        sw[i]=sw[i-1]+a[i].val;

        sd[i]=sd[i-1]+d[i-1];

        cost[i]=cost[i-1]+sw[i-1]*d[i-1];

    }

    sw[n+1]=sw[n];

    sd[n+1]=sd[n]+d[n];

    cost[n+1]=cost[n]+sw[n]*d[n];

}

ll check(ll x,ll y)

{

    if(x<y)swap(x,y);

//    cout<<"@@@"<<cost[n+1]-sw[y]*(sd[x]-sd[y])-sw[x]*(sd[n+1]-sd[x])<<"\n";

    return cost[n+1]-sw[y]*(sd[x]-sd[y])-sw[x]*(sd[n+1]-sd[x]);

}

void work()

{

     for(ll i=1;i<=30;i++)tp[i][1]=rand()%n+1,tp[i][2]=rand()%n+1;

     double T=n;

     while(T>=1)

     {

         for(ll i=1;i<=30;i++)

         {

             for(ll j=1;j<=80;j++)

             {

                 /*ll delta=sin((((double)(rand()%10000))/10000.0)*2*PI)*T;

                 ll now1=tp[i][1]+delta;

                 ll now2=tp[i][2]+delta;*/

                 ll now1=(ll)tp[i][1]*(1-double((rand()%(ll(T+0.5)+1))/double(n))+double((rand()%(ll(T+0.5)+1))/double(n)));

                ll now2=(ll)tp[i][2]*(1-double((rand()%(ll(T+0.5)+1))/double(n))+double((rand()%(ll(T+0.5)+1))/double(n)));

                 if(now1<=0||now1>=n||now2<=0||now2>n||check(now1,now2)>=check(tp[i][1],tp[i][2]))continue;

                 //cout<<now1<<" "<<now2<<"<---\n";

                 tp[i][1]=now1;

                 tp[i][2]=now2;

            }

        }

         T*=0.9;

     }

     ll minn=1e18;

     for(ll i=1;i<=30;i++)minn=min(minn,check(tp[i][1],tp[i][2]));

     printf("%lld\n",minn);

}

int main()

{

    init();

    work();

return 0;

}

是不是有一点像模拟退火？ （逃

2.随机+其他算法

这一类就纯粹是随机乱搞+其他算法验证。

2971 -- 【模拟试题】生日礼物

Description

　　一对双胞胎兄妹同一天过生日，这一天，他们的朋友给他俩送来了礼物，每个人送的礼物都是2本书，一本给哥哥，一本给妹妹，但没有说明哪本是给妹妹的，哪本是给哥哥的，每本书都有自己的价值，为了避免冲突，让你来分配，要求使得两人所获得书本的价值和之间的差距尽可能的小。

　　例如，有4个礼物：(3,5),(7,11),(8,8),(2,9),可以把3,7,8,2分配给妹妹，其余的给哥哥，价值差为：5+11+8+9-3-7-8-2=13;如果把3，7，8，9给妹妹，其余的给哥哥，价值差为：3+7+8+9-5-11-8-2=1，这是最好的方案。

Input

　　输入文件gift.in的第一行包含一个正整数N，表示礼物的数量，接下来N行，每行两个整数，表示每份礼物两本书的价值(价值范围在1到300之间)。

Output

　　输出文件gift.out包含一个非负整数，表示最小的价值差。

Sample Input

4

3 5

7 11

8 8

2 9

Sample Output

1

Hint

【数据规模】

　　对于20%的数据，有N≤20；

　　对于40%的数据，有N≤50；

　　对于100%的数据，有N≤150。

这个题的标解算法是DP，有思考难度。

当然，也可用 随机乱搞算法！

将输入的礼物随机打乱，然后用 贪心来处理这个随机礼物序列，速度非常快。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cstdlib>
//#include<cmath>
using namespace std;
inline int read()
{
        int bj=1;
        char ch=getchar();
        while(ch<'0'||ch>'9')
        {
                if(ch=='-')bj=-1;
                ch=getchar();
        }
        int ret=0;
        while(ch>='0'&&ch<='9')ret=ret*10+ch-'0',ch=getchar();
        return ret*bj;
}
struct node
{
        int a,b;
}w[250];
int n;
void form()
{
        for(int i=1;i<=n;i++)
        {
                int pos=rand()%n+1;
                swap(w[i],w[pos]);
        }
}
void Randwork()
{
        int T=550;
        int minn=0x7fffffff;
        while(T--)
        {
                form();
                int sum1=0,sum2=0;
                for(int i=1;i<=n;i++)
                {
                        if(sum1>=sum2)
                        {
                                sum1+=min(w[i].a,w[i].b);
                                sum2+=max(w[i].a,w[i].b);
                        }
                        else
                        {
                                sum1+=max(w[i].a,w[i].b);
                                sum2+=min(w[i].a,w[i].b);
                        }
                }
                minn=min(minn,abs(sum2-sum1));
        }
        cout<<minn;
}
int main()
{
        srand(140707);
        n=read();
        for(int i=1;i<=n;i++)
        {
                w[i].a=read();
                w[i].b=read();
        }
        Randwork();
return 0;
}