1 #include<stdio.h>  
  2 int x,y,k;  
  3 int array[36][36];  
  4 int result[31];  
  5 //初始化杨辉三角  
  6 void init_array()  
  7 {  
  8     array[0][0] = 1;  
  9     for(int i = 1;i < 31;++i)  
 10     {  
 11         for(int j = 0;j <= i;++j)  
 12         {  
 13             if(j == 0 ||j == i)  
 14             {  
 15                 array[i][j] = 1;  
 16             }  
 17             else  
 18             {  
 19                 array[i][j] = array[i - 1][j - 1] + array[i- 1][j];  
 20             }  
 21         }  
 22     }  
 23 }  
 24   
 25 int get_num_count(int num)  
 26 {  
 27     int total = 0;  
 28     while(num > 0)  
 29     {  
 30         ++total;  
 31         num /= 2;  
 32     }  
 33     return total;  
 34 }  
 35   
 36 //去掉首位的1  
 37 int delete_highest(int num)  
 38 {  
 39     int count = get_num_count(num);  
 40     int total = 1<<(count - 1);  
 41     total = ~total;  
 42     return num & total;  
 43 }  
 44   
 45 //计算跟一个数2进制位数相同的最大值  
 46 int getMin(int total_nums,int one_nums)  
 47 {  
 48     int total = 0;  
 49     if(total_nums < one_nums)  
 50         return -1;  
 51     for(int i = 0;i < one_nums;++i)  
 52     {  
 53         total = total * 2 + 1;  
 54     }  
 55     for(int j = one_nums;j < total_nums;++j)  
 56     {  
 57         total *= 2;  
 58     }  
 59     return total;  
 60 }  
 61 //计算跟一个数2进制位数相同的最小值  
 62 int getMax(int total_nums,int one_nums)  
 63 {  
 64     int total = 1;  
 65     if(total_nums < one_nums)  
 66         return 1000000001;  
 67     for(int i = 0;i < total_nums - one_nums;++i)  
 68     {  
 69         total = total * 2;  
 70     }  
 71     for(int j = 1;j < one_nums;++j)  
 72     {  
 73         total = total * 2 + 1;  
 74     }  
 75     return total;  
 76 }  
 77   
 78   
 79 int recursive_deal(int start,int end,int one_nums)  
 80 {  
 81     if(start > end)  
 82         return 0;  
 83     int start_count = get_num_count(start);  
 84     int end_count = get_num_count(end);  
 85     if(one_nums == 0)  
 86     {  
 87         if(start == 0 || end == 0)  
 88             return 1;  
 89         else  
 90             return 0;  
 91     }  
 92     else  
 93     //如果始末两个数的位数相同的话，就去掉最高位  
 94     if(start_count == end_count)  
 95     {  
 96             return recursive_deal(delete_highest(start),delete_highest(end),one_nums - 1);  
 97     }  
 98     else    //如果始末两个数的位数不同的话，分别计算和起始，终止的的数的2进制位数，中间的数的数量可以通过排列组合计算出来  
 99     {  
100         int total = 0;  
101         for(int i = start_count + 1;i < end_count;++i)  
102         {  
103             total += array[i - 1][one_nums - 1];  
104         }  
105         return total + recursive_deal(start,getMin(start_count,one_nums),one_nums) + recursive_deal(getMax(end_count,one_nums),end,one_nums);  
106     }  
107 }  
108   
109 int main()  
110 {  
111     int tests;  
112     init_array();  
113     scanf("%d",&tests);  
114     while(--tests >= 0)  
115     {  
116         scanf("%d%d%d",&x,&y,&k);  
117         printf("%d\n",recursive_deal(x,y,k));  
118     }  
119     return 0;     
120 }  

崔佳星 2012-04-07 10:21 发表评论

 1 #include<stdio.h>  
 2 #include<algorithm>  
 3 int n,m;  
 4 int heads[20010];  
 5 int knights[20010];  
 6   
 7   
 8 int cmp(const void *first,const void * second)  
 9 {  
10     return *((int*)first) - *((int*)second);  
11 }  
12   
13 //返回-1表示不可能  
14 int deal()  
15 {  
16     if(n > m)  
17         return -1;  
18     qsort(heads,n,sizeof(int),cmp);  
19     qsort(knights,m,sizeof(int),cmp);  
20     int i = 0,j = 0;  
21     int total = 0;  
22     for(i = 0;i < n;++i)  
23     {  
24         while(knights[j] < heads[i] && j < m)  
25         {  
26             ++ j;  
27         }  
28         if(j == m)  
29             break;  
30         else  
31         {
32             total += knights[j];  
33             ++j;
34         }
35     }  
36     if(i == n)  
37         return total;  
38     else  
39         return -1;  
40   
41 }  
42   
43 int main()  
44 {  
45     int i;  
46     int result;  
47     while(scanf("%d%d",&n,&m))  
48     {  
49         if(m == 0 &&n == 0)  
50             break;  
51         for(i = 0;i < n;++i)  
52         {  
53             scanf("%d",&heads[i]);  
54         }  
55         for(i = 0;i < m;++i)  
56         {  
57             scanf("%d",&knights[i]);  
58         }  
59         result = deal();  
60         if(result == -1)  
61         {  
62             printf("Loowater is doomed!\n");  
63         }  
64         else  
65         {  
66             printf("%d\n",result);  
67         }  
68     }  
69     return 0;  
70 }  

崔佳星 2012-04-06 20:43 发表评论

#include<stdio.h>
#include<malloc.h>
#include<queue>
#include<string.h>
using namespace std;
typedef struct node
{
    int id;
    int distance;
    struct node *next;
}Node,*LNode;
int n,m;
LNode array[100010];//邻接链表
int in_queue[100010];//记录一个点是否在队列中
int between_distance[100010];//记录起始点到两个点之间的距离
queue<int> q;//建立一个队列

void init_array()
{
    for(int i = 0;i <= n;++i)
    {
        array[i] = (LNode)malloc(sizeof(Node));
        array[i]->id = i;
        array[i]->distance = 0;
        array[i]->next = NULL;
    }
}

void insert_node(LNode header,LNode &insert_node)
{
    while(header->next != NULL)
        header = header->next;
    insert_node->next = header->next;
    header->next = insert_node;
}

//任何两点之间的距离设置为-1，表示正无穷
void init_distance()
{
    for(int i = 0;i <= n;++i)
    {
        between_distance[i] = -1;
    }
    //第一个结点到自身为0
    between_distance[1] = 0;
}

//松弛
void relax(int index)
{
    if(between_distance[index] == -1)
        return ;
    LNode header = array[index]->next;
    while(header != NULL)
    {
        if(between_distance[header->id] > between_distance[index] + header->distance || between_distance[header->id] == -1)
        {
            between_distance[header->id] = between_distance[index] + header->distance;
            if(!in_queue[header->id])
            {
                q.push(header->id);
                in_queue[header->id] = 1;
            }
        }
        header = header->next;
    }
}

void SPFA()
{
    //第一个点入队列
    q.push(1);
    in_queue[1] = 1;
    int index = 0;
    while(!q.empty())
    {
        index = q.front();
        q.pop();
        in_queue[index] = 0;
        relax(index);
    }
}

int main()
{
    int x,y,distance;
    scanf("%d%d",&n,&m);
    init_array();
    for(int i = 0;i < m;++i)
    {
        scanf("%d%d%d",&x,&y,&distance);
        LNode node = (LNode)malloc(sizeof(Node));
        node->id = y;
        node->distance = distance;
        insert_node(array[x],node);
        node = (LNode)malloc(sizeof(Node));
        node->id = x;
        node->distance = distance;
        insert_node(array[y],node);
    }
    init_distance();
    memset(in_queue,0,sizeof(in_queue));
    SPFA();
    if(between_distance[n] == -1)
    {
        printf("-1\n");
    }
    else
        printf("%d\n",between_distance[n]);
    return 0;
}

崔佳星 2012-04-06 19:59 发表评论

 1 #include<stdio.h>  
 2 char array[110];  
 3 int zero,one;  
 4 int i;  
 5 int dp(int n)  
 6 {  
 7     if(array[0] == '0')  
 8     {  
 9         zero = 0;  
10         one = 1;  
11     }  
12     else  
13     {  
14         zero = 1;  
15         one = 0;  
16     }  
17     for(i = 1;i < n;++i)  
18     {  
19         if(array[i] == '0')  
20         {  
21             if(array[i] != array[i - 1])  
22                 ++one;  
23         }  
24         else  
25         {  
26             if(array[i] != array[i - 1])  
27                 ++ zero;  
28         }  
29     }  
30     return zero < one?zero:one;  
31 }  
32   
33 int main()  
34 {  
35     int t,n;  
36     scanf("%d",&t);  
37     while(t-- != 0)  
38     {  
39         scanf("%d",&n);  
40         scanf("%s",array);  
41         printf("%d\n",dp(n));  
42     }  
43     return 0;  
44 }  

崔佳星 2012-04-06 10:35 发表评论