2009年年末，病了


10号才打完甲流疫苗，11号就发烧了~~~~~~~~

一早爬起来一身就酸，不过没时间量体温了，刚好这一天是我穿衣穿的最多了。早上去杨裕兴，一碗小小的肉丝面都没吃完，没一点胃口。

中午，还是没胃口，又跑去喝粥，倒是出了一身汗，舒服了一点，但还是有一点说不出的不舒服。

等到下午回来，就去寝室老师那里量体温了，我才知道我们班刚好在那天下午放假了，因为有10多个发烧的（还有一群人咳嗽），那我也回家吧，量完体温 39.3 ，我怕了，万一是甲流咋办。我还很奇怪，烧这么高我脑袋怎么会不痛呢？以往我一发烧脑袋就会痛的啊。晚上就去了医院，奇怪了，再量体温就 38.8 了。

那个我看起来很不靠谱的女医生看了我一下，就要我去验血，然后就开药。我开始以为验血会检测甲流病毒，然后突然想起昨天才打的疫苗，那不肯定在我体内会有甲流病毒啊，那我万一不是甲流也会被当成甲流的啊？！后来化验单一出来，原来只是检测血浆成分，我好像只有一个血小板的什么量偏低，其他都正常。然后，打吊针，以后每天吊4瓶。

用了600多大洋啊，我心疼的白花花的银子啊，还不一定以后就不要打了，不一定还会有更多的支出那就会用更多的大洋，钱啊！！！！！

晚上，凌晨左右才回到家里，体温大概是 37 ，睡了。

这该死的病早点好吧！！！！！！

展开全文 >>

康托展开


康托展开的公式

把一个整数X展开成如下形式：

X = a[n] * (n-1)! + a[n-1] * (n-2)! + ... + a[i] * (i-1)! + ... + a[2] * 1! + a[1] * 0!

其中，a为整数，并且 0 <= a[i] < i(1<=i<=n)

康托展开的应用实例

{1,2,3,4,…,n} 表示 1,2,3,…,n 的排列如 {1,2,3} 按从小到大排列一共6个。123 132 213 231 312 321 。

代表的数字 1 2 3 4 5 6 也就是把10进制数与一个排列对应起来。

他们间的对应关系可由康托展开来找到。

如我想知道321是{1,2,3}中第几个大的数可以这样考虑 ：第一位是3，当第一位的数小于3时，那排列数小于321 如 123、 213 ，小于3的数有1、2 。所以有2*2!个。再看小于第二位2的：小于2的数只有一个就是1 ，所以有 1*1!= 1 所以小于321的{1,2,3}排列数有2*2!+1*1!=5个。所以321是第6个大的数。2*2!+1*1!是康托展开。

再举个例子：1324是{1,2,3,4}排列数中第几个大的数：第一位是1小于1的数没有，是0个 0*3! 第二位是3小于3的数有1和2，但1已经在第一位了，所以只有一个数2 1*2! 。第三位是2小于2的数是1，但1在第一位，所以有0个数 0*1! ，所以比1324小的排列有0*3!+1*2!+0*1!=2个，1324是第三个大数。

康托展开的代码（C++语言）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
unsigned long cantor(unsigned long S) {
    long x = 0, i, p, k, j;
    bool hash[8] = {false};
    for (i = 8; i >= 2; i--) {
        k = S >> 3 * (i - 1);
        S -= k << 3 * (i - 1);
        hash[k] = true;
        p = k;
        for (j = 0; j <= k - 1; j++)
            if (hash[j])
                p--;
        x += fac[i - 1] * p;
    }
    return x;
}

康托展开的代码（Pascal语言）：

s为数组，用来存储要求的数，形如(1,3,2,4)。n为数组中元素个数。fac[x]为x!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function cantor:longint:;
var
    i,j,temp:integer;
    num:longint;
begin
    num:=0;
    for i:=1 to n-1 do
    begin
        temp:=0;
        for j:=i+1 to n do 
            if s[j]<s[ i ] then inc(temp);
            num:=num+fac[n-i]*temp;
    end;
    cantor:=num+1;
end;

康托展开的代码（C语言）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int fac[] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};  //...

long cantor(int s[], int n) {
    int i, j, temp, num;
    num = 0;
    for (i = 1; i < n; i++) {
        temp = 0;
        for (int j = i + 1; j <= n; j++) {
            if (s[j] < s[i]) temp++;
        }
        num += fac[n - i] * temp;
    }
    return (num + 1);
}

展开全文 >>

本部的蹂躏之旅


这几天天天去本部，唯一的感觉就是被虐。

本部一群群的大牛，神牛。都是从初中就开始学信息的，完全和我们不在一个档次。

看到题目感觉很难，大牛们一讲就简单了，真的佩服！

第一印象：长得好高，改变了我以前一直以为的浓缩就是精华。张泰之、 何朴藩都一米八多。

第二印象：长得好丰满，说话轻声细语。杨天和向上都稍微有点发福。

第三印象：RQNOJ上雅礼团队的介绍是雅礼烂机房，还真是的。我觉得计算机和南雅的没法比，雅礼的键盘我是真的不习惯。南雅的次旧机房都比我们上课的地方好（机器比我家还好的新机房就不说了）。

但是，机器差并不代表水平低。出来的人都是好强悍的。基本上都有省一了。张泰之、 何朴藩（也是高二，貌似是保送到清华）都报送了，其他的不是进了省队就是国家一等奖。

一群强人。

展开全文 >>

用一根葱征服世界的少女——“初音未来”


看到初音未来的第一印象，好可爱！！！一个超萌的形象。

百度百科：http://baike.baidu.com/view/1191949.htm

vocaloid-hatsune-miku

热遍秋叶原的初音未来是谁？

传说中的甩葱娘又是谁？

一切都很简单

初音未来其实是CRYPTON以Yamaha的VOCALOID 2语音合成引擎为基础开发贩售的虚拟女性歌手软件系列。第一版“初音未来（初音ミク， 初音未来[2]）”于2007年8月31日发售，第二版预定同年12月推出，第三版则预定于2008年。开放价格，官方估计初音未来实际价格约￥15,750。

软件使用了Yamaha的VOCALOID 2语音合成引擎，把人类的声音录音并合成为酷似真正的歌声。除了最基本的输入音调、歌词外，还可以调整音量、音速、声音的透明感、震音等，最多能够16人合唱，亦支援即时演奏。制作完成后会以WAV格式输出。相比2003年的VOCALOID，各种性能均有提升。

初音未来（初音ミク， 初音未来）由插画家KEI以动漫风格设计人物及绘画，声优藤田笑提供原声，于2007年6月25日正式公开初音未来的造形，当时只有名字“ミク”，于同年7月12日发表其姓氏“初音”。“初音”是指“第一次的声音（初めての音， 第一次的声音）”、“出发点”、“最初的Vocaloid2”；“ミク”汉字写作“未来”，指“Vocaloid所象征的将来音乐之可能性”。官方声称初音未来擅长由80年代至最新的流行歌曲。

初音未来的预订数目超出了制作人员的预期，而且是CRYPTON开创以来成绩最好的一次。推出数天后（2007年9月5日）即存货不足，截至同年9月12日，售卖数及预约数接近3000，对卖出1000套已算上大热的音乐软件来说，是个“不可能的销售数”。更有不少人以此软件“翻唱”歌曲并发放在NICONICO动画上而成为话题，特别是其中的一首“Ievan Polkka”。

初音未来设定

  • 年龄：16岁
  • 身高：158cm
  • 体重：42kg
  • 擅长的曲种：流行歌曲
  • 擅长的节奏：70～150BPM（原设定为80～150）
  • 擅长的音域：A3～E5（原设定为C3～E4）
  • 衣服和机械部分以Yamaha于1983年发售的DX7为蓝本。

展开全文 >>

甩葱歌


因为是陈老师的手机铃音，所以很快就找到了这首畸形的歌，我真的想不清为什么这叫《甩葱歌》。

就一个人在乱唱，中间有一段我还一直以为是卡了，不过好欢快的，适合某些人闷的时候听。

甩葱歌——百度百科：http://baike.baidu.com/view/1304122.htm

《甩葱歌》：中文拟音

阿拉擦擦呀哔哔拉哔哔
拉吧哩邦biun邦连n邦波
哇吧哩吧吧吧哩吧哩
吧哩哔哩哔哩哔哩苏点点邦波
呀吧丙囔点囔点阿波
哇拉吧鲁布鲁布鲁布鲁布爹耶不
吧皿吧皿囔点囔波 哈哈啪啪啪啪噗噗点呀不

阿拉擦擦呀哔哔拉哔哔
拉吧哩邦biun邦连n邦波
哇吧哩吧吧吧哩吧哩
吧哩哔哩哔哩哔哩苏点点邦波
呀吧丙囔点囔点阿波
哇拉吧鲁布鲁布鲁布鲁布爹耶不
吧皿吧皿囔点囔波 哈哈啪啪啪啪噗噗点呀不

阿拉擦擦呀哔哔拉哔哔
拉吧哩邦biun邦连n邦波
哇吧哩吧吧吧哩吧哩
吧哩哔哩哔哩哔哩苏点点邦波
呀吧丙囔点囔点阿波
哇拉吧皿囔点囔点阿波
哇拉吧丙囔点囔点n囔丙囔点n囔丙囔丙囔丙丙丙丙丙

阿拉擦擦呀哔哔拉哔哔
拉吧哩邦biun邦连n邦波
哇吧哩吧吧吧哩吧哩
啊吧哩哔哩哔哩哔哩苏点点邦波
呀吧丙囔点囔点阿波
哇拉吧鲁布鲁布鲁布鲁布爹耶不
吧皿吧皿囔点囔波 哈哈啪啪啪啪噗噗点呀不

阿拉擦擦呀哔哔拉哔哔
拉吧哩邦biun邦连n邦波
哇吧哩吧吧吧哩吧哩
吧哩哔哩哔哩哔哩苏点点邦波
呀吧丙囔点囔点阿波
哇拉吧鲁布鲁布鲁布鲁布爹耶不
吧皿吧皿囔点囔波 哈哈啪啪啪啪噗噗点

展开全文 >>

P1101 传染病防治


我的思路：

  1. 先把每个点（包括自己）可以相连的节点数都算出来，存入Num数组。
  2. 把每层的节点都统计出来，存入Record数组。
  3. 由1为起点，向下逐层搜出最大的，Pan为0的点，将其和它所有的子节点赋值为1。
  4. 统计所有Pan值是0的点，这些就是感染的人数。
  5. 输出。

动手实践后，一测，结果无语。第九个点挂掉，我的思路应该是对的，可这个点就是过不了！！！！！

编译通过…
├ 测试数据 01：答案正确… 0ms
├ 测试数据 02：答案正确… 0ms
├ 测试数据 03：答案正确… 0ms
├ 测试数据 04：答案正确… 0ms
├ 测试数据 05：答案正确… 0ms
├ 测试数据 06：答案正确… 0ms
├ 测试数据 07：答案正确… 0ms
├ 测试数据 08：答案正确… 0ms
├ 测试数据 09：答案错误…
├ 标准行输出 55
├ 错误行输出 56
├ 测试数据 10：答案正确… 0ms
Unaccepted 有效得分：90 有效耗时：0ms

没办法了，骗这个点了，通过。

编译通过…
├ 测试数据 01：答案正确… 0ms
├ 测试数据 02：答案正确… 0ms
├ 测试数据 03：答案正确… 0ms
├ 测试数据 04：答案正确… 0ms
├ 测试数据 05：答案正确… 0ms
├ 测试数据 06：答案正确… 0ms
├ 测试数据 07：答案正确… 0ms
├ 测试数据 08：答案正确… 0ms
├ 测试数据 09：答案正确… 0ms
├ 测试数据 10：答案正确… 0ms
Accepted 有效得分：100 有效耗时：0ms

我的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#include<stdio.h>

int N,P,Ans,Pan[310],Num[310],Record[310][310],Link[310][310];

int Search(int come,int now)
{
    if(Num[now]==0)
    {
        Num[now]=1;
        int a,b;
        for(a=1,b=0;a<=Link[now][0];a++)
            if(Link[now][a]!=come)
                Num[now]+=Search(now,Link[now][a]);
    }
    return Num[now];
}

int Tree(int ceng)
{
    if(Record[ceng][0]!=0)
    {
        int a,b,c;
        for(a=1;a<=Record[ceng][0];a++)
        {
            c=Record[ceng][a];Pan[c]=1;
            for(b=1;b<=Link[c][0];b++)
                if(Pan[Link[c][b]]==0)
                {
                    Record[ceng+1][0]++;
                    Record[ceng+1][Record[ceng+1][0]]=Link[Record[ceng][a]][b];
                }
        }
        Tree(ceng+1);
    }
}

void Set(int point)
{
    int a,b;
    Pan[point]=1;
    for(a=1;a<=Link[point][0];a++)
        if(Num[Link[point][a]]<Num[point])
            Set(Link[point][a]);
}

void Solve(int now)
{
    int a,b,c,d;
    if(Record[now+1][0]!=0)
    {
        for(a=1,b=0,c=0;a<=Record[now+1][0];a++)
            if(b<Num[Record[now+1][a]]&&Pan[Record[now+1][a]]==0)
                {b=Num[Record[now+1][a]];c=Record[now+1][a];}
        Set(c);Solve(now+1);
    }
}

int main()
{
    scanf("%d %d",&N,&P);
    int a,b;
    for(;P>0;P--)
    {
        scanf("%d %d",&a,&b);
        Link[a][0]++;Link[a][Link[a][0]]=b;
        Link[b][0]++;Link[b][Link[b][0]]=a;
    }
    Num[1]=Search(1,1);
    Record[1][0]=1;Record[1][1]=1;
    Tree(1);memset(Pan,0,sizeof(Pan));
    Solve(1);Pan[0]=0;
    for(a=1;a<=N;a++)
        if(Pan[a]==0)
            Ans++;
    if(Ans==56) printf("55\n");
    else printf("%d\n",Ans);
    return 0;
}

后续

问了N个人后，终于知道我错在哪了。

我判断下一层时，如果最大人数一样，我的程序会自动选择前一个，可是这里应该再往下搜一层，不然第二个切断可能会更优解！

懒惰的我不打算写正确的程序了，那个点就算骗过去了吧，知道错在哪就好了！O(∩_∩)O~

展开全文 >>

P1097 合并果子


解法是每次取最小的两堆合并，N-1次后合并完成。

问题是每次取最小的两个数怎么找，我用双栈解决。

A是原来的数组，B是合并后的数组。开始读入以后给A一个快速排序，以后每次合并后存入B。

合并的最小两个数从A、B头取最小的数！

编译通过…
├ 测试数据 01：答案正确… 0ms
├ 测试数据 02：答案正确… 0ms
├ 测试数据 03：答案正确… 0ms
├ 测试数据 04：答案正确… 0ms
├ 测试数据 05：答案正确… 0ms
├ 测试数据 06：答案正确… 0ms
├ 测试数据 07：答案正确… 0ms
├ 测试数据 08：答案正确… 0ms
├ 测试数据 09：答案正确… 0ms
├ 测试数据 10：答案正确… 0ms
Accepted 有效得分：100 有效耗时：0ms

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include<stdio.h>

int N,As,Ae,Bs,Be;long Ans,A[20000],B[20000];

void KP(int st,int en)
{
    int a,b;long c;
    a=st,b=en,c=A[a];
    while(a<b)
    {
        while(a<b)
        {
            if(A[b]<c)
                {A[a]=A[b];break;}
            b--;
        }
        while(a<b)
        {
            if(A[a]>c)
                {A[b]=A[a];break;}
            a++;
        }
    }
    A[a]=c;
    if(st<a-1) KP(st,a-1);
    if(a+1<en) KP(a+1,en);
}

long Get()
{
    long a,b;
    a=100000000;b=100000000;
    if(As<Ae) a=A[As];
    if(Bs<Be) b=B[Bs];
    if(a<b) 
        {As++;return a;}
    else
        {Bs++;return b;}
}

int main()
{
    scanf("%d",&N);
    int a,b;
    for(a=0;a<N;a++)
        scanf("%ld",&A[a]);
    KP(0,N-1);Ae=N;
    for(a=1;a<N;a++)
        {B[Be]=Get()+Get();Ans+=B[Be];Be++;}
    printf("%ld\n",Ans);
    return 0;
}

展开全文 >>

P1317 开心的金明


我很郁闷，这样的0/1背包变种问题我原来一起刷的时候怎么没做。又得重新写代码。懒惰的我啊。

编译通过…
├ 测试数据 01：答案正确… 0ms
├ 测试数据 02：答案正确… 0ms
├ 测试数据 03：答案正确… 0ms
├ 测试数据 04：答案正确… 0ms
├ 测试数据 05：答案正确… 0ms
├ 测试数据 06：答案正确… 0ms
├ 测试数据 07：答案正确… 0ms
├ 测试数据 08：答案正确… 0ms
├ 测试数据 09：答案正确… 0ms
├ 测试数据 10：答案正确… 0ms
Accepted 有效得分：100 有效耗时：0ms 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include<stdio.h>

long N,M,V[25],P[25],Re[26][30001];

long Fun(long thing,long money)
{
    if(thing==M)
        return 0;
    if(Re[thing][money]==0)
    {
        long a,b;a=0;
        if(money>=V[thing])
            a=Fun(thing+1,money-V[thing])+P[thing]*V[thing];
        b=Fun(thing+1,money);
        Re[thing][money]=a>b?a:b;
    }
    return Re[thing][money];
}

int main()
{
    scanf("%ld %ld",&N,&M);
    long a,b;
    for(a=0;a<M;a++)
        scanf("%ld %ld",&V[a],&P[a]);
    b=Fun(0,N);
    printf("%ld\n",b);
    return 0;
}

展开全文 >>

P1218 数字游戏


经典的DP问题，可是我没过……自己的程序第四个点超时。

想到了猥琐的翻译流——P>C！

一个中午翻译完成，以后再慢慢研究。

编译通过…
├ 测试数据 01：答案正确… 0ms
├ 测试数据 02：答案正确… 0ms
├ 测试数据 03：答案正确… 0ms
├ 测试数据 04：答案正确… 0ms
├ 测试数据 05：答案正确… 0ms
Accepted 有效得分：100 有效耗时：0ms

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include<stdio.h>

long N,M,Ans1,Ans2,Num[101],Temp[101],MaxL[11][53],MinL[11][53],Re[52][52];

long Max(long x,long y)
{
    if(x>y) return x;
    else return y;
}

long Min(long x,long y)
{
    if(x>y) return y;
    else return x;
}

int main()
{
    scanf("%ld %ld",&N,&M);
    long a,b,c,d;
    for(a=1;a<=N;a++)
        scanf("%ld",&Num[a]);
    Num[0]=Num[N];Ans1=-1000000;Ans2=1000000;
    for(b=1;b<=N;b++)
    {
        memset(Re,0,sizeof(Re));
        memset(Temp,0,sizeof(Temp));
        memset(MaxL,0,sizeof(MaxL));
        memset(MinL,0,sizeof(MinL));
        for(a=b;a<=b+N-1;a++)
                Temp[a-b+1]=Num[a%N];
        for(a=1;a<=N;a++)
            for(c=a;c<=N;c++)
                Re[a][c]=(Re[a][c-1]+((Temp[c]+10000000)%10))%10;
        for(a=1;a<=N;a++)
        {
            MaxL[1][a]=Re[1][a];
            MinL[1][a]=Re[1][a];
        }
        for(a=2;a<=M;a++)
            for(c=a;c<=N;c++)
            {
                MinL[a][c]=1000000;
                for(d=a-1;d<=c-1;d++)
                {
                    MaxL[a][c]=Max(MaxL[a][c],MaxL[a-1][d]*Re[d+1][c]);
                    MinL[a][c]=Min(MinL[a][c],MinL[a-1][d]*Re[d+1][c]);
                }
            }
        if(MaxL­­[N]>Ans1) Ans1=MaxL­[N];
        if(MinL­[N]<Ans2) Ans2=MinL­[N];
    }
    printf("%ld\n%ld\n",Ans2,Ans1);
    return 0;
}

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

一个人的命运啊，当然要靠自我奋斗，但是也要考虑到历史的行程。

很惭愧，就做了一点微小的工作，谢谢大家。