hdu4671 思维构造

http://acm.hdu.edu.cn/showproblem.php?

pid=4671

Problem Description

Makomuno has N servers and M databases. All databases are synchronized among all servers and each database has a ordered list denotes the priority of servers to access. This list is guaranteed to be a valid permutation of all servers.
Every time someone wants to execute queries on a certain database, he will send a request to the first server in the list. If it's dead, he will simply turn to the next one. Otherwise a working copy of the database is found, and this copy is called active.
Now, given N and M, Makomuno wants to find a permutation for each database which could assure that all servers are load-balanced. Moreover, Makomuno hopes the system will be load-balanced even if exactly one server is broken.
Note that if we call the number of active copies on i-th server A_i, then load-balanced means max∣A_i - A_j∣≤1 for any i and j in non broken servers set. We won't consider broken servers in this case.

 

Input

The input contains several test cases, terminated by EOF.
Each test case has one line containing two integer N ( 2≤N≤100) and M ( 1≤M≤100).

 

Output

For each case output M lines, the i-th line contains a permutation of all servers, indicating the expected order. Servers are numbered from 1 to n.

 

Sample Input

5 3

 

Sample Output

2 4 3 1 5
1 5 4 2 3
3 5 2 4 1
Hint
In the sample test case, the active copies of these databases are on server 2,1 and 3 in normal state. A = {1,1,1,0,0}
If server 1 or 3 has broken, server 5 will take its work. In case we lost server 2, the second database will use server 4 instead. A = {1,BROKEN,1,1,0}
It's clear that in any case this system is load-balanced according to the plan in sample output. 
 

/**
hdu4671  思维构造
题目大意：有n台server和m个数据库，我们要用server执行数据库。对于每一个数据库被执行server的优先级为1~n的一个排列，每一个数据库仅仅执行一次，
           问如何定义m个数据库的优先级，如果有一台server坏了的情况下仍然满足每台server的执行数据库的数量差不能大于1
解题思路：这个题是一个考验思维的题，当然答案有非常多。我仅仅要确定每一个数据库优先级最高和次高的就能够了，我们分两种情况来讨论：
           1.n>=m 在这样的情况下1~m第一优先级的为1~m，第二优先级的为余下的随意（若n==m，则全部随意。要保证第一第二不能是一个数）
           2.n<m  在这样的情况下1~m为1~n，再1~n，知道循环够m。第二优先级。我们对于第一优先级一样的放在一块考虑，从n~1循环（和第一反复就跳过）。

           为什么这样呢？由于如果i坏了。那么第二优先级添加的还是各一个，仍保证是对的。注意要n~1循环，由于第m不一定是n的倍数。所以有i~n
           可能会在第一优先级里少排一个，我们在第二优先级里要优先考虑，否则会出现有一个坏了的话差大于1的情况
*/
#include <string.h>
#include <stdio.h>
#include <iostream>
#include <algorithm>
using namespace std;
int n,m,a[105][2],flag[105];
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        if(n>=m)
        {
            for(int i=1;i<=m;i++)
            {
                a[i][0]=i;
                if(a[i][0]==n)
                   a[i][1]=1;
                else
                   a[i][1]=n;
            }
        }
        else
        {
            for(int i=1;i<=m;i++)
            {
                a[i][0]=(i%n==0)?n:i%n;
            }
            for(int i=1;i<=n;i++)
            {
                int k=n;
                for(int j=1;j<=m;j++)
                {
                    if(a[j][0]==i)
                    {
                        k=(k%n==0)?n:k%n;
                        if(k==i)k--;
                        k=(k%n==0)?n:k%n;
                        a[j][1]=k--;
                       // printf("?
?
%d:%d\n",a[j][0],a[j][1]);
                    }
                }
            }
        }
        for(int i=1;i<=m;i++)
        {
            //printf(">>%d %d\n",a[i][0],a[i][1]);
        }
        for(int i=1;i<=m;i++)
        {
            memset(flag,0,sizeof(flag));
            printf("%d %d",a[i][0],a[i][1]);
            flag[a[i][0]]=flag[a[i][1]]=1;
            for(int j=1;j<=n;j++)
            {
                while(flag[j])j++;
                if(j>n)break;
                printf(" %d",j);
                flag[j]=1;
            }
            printf("\n");
        }
    }
    return 0;
}
/**
3 14
answer：
1 3 2
2 3 1
3 2 1
1 2 3
2 1 3
3 1 2
1 3 2
2 3 1
3 2 1
1 2 3
2 1 3
3 1 2
1 3 2
2 3 1
*/