uva 10123

题意：从一个木板中依次拿下木快，在这个过程中始终保持平衡（不一定是水平的才是平衡，纠结了好久），那如果按照题意直接来会很麻烦，所以我们想着依次放上去，让它保持平衡。

参考了别人的优化：

“第一，最好把坐标先乘2化成整数，这样就避免了浮点数误差。

    “第二，我们在放的时候，一个贪心思路就是先把两个支点中间的木块放上，比较容易证明这样只会增加后续木板的稳定程度。

    “第三，我们应该把其余的木块按力矩大小降序排序，支点是离它最近的那个支点，先选力矩小的，这样一定程度上减少了木板弄翻的可能。

    “第四，上面的按力矩排序还带来了额外的好处，我们不妨用两个数组分别存左边和右边的待放的木块。我们先考虑右边的，假设我们现在放了一个木块上去，结果发现后面无论怎么放木板都会右翻，显然就不用再尝试这个木块右边的木块了，因为必然也会右翻。同样，对于左边的木块，假设我们现在放了一个木块上去，结果发现后面无论怎么放木板都会左翻，显然就不用再尝试这个木块左边的木块了，因为必然也会左翻。当然，如果后续可能左翻也可能右翻的话就要继续尝试剩余的木块。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN = 30;

int N,L,M,N1,N2;
int vis[MAXN],x[MAXN],w[MAXN],s[MAXN],r1[MAXN],r2[MAXN];

int cmp(const void *_a,const void *_b)
{
    int a = *(int *)_a;
    int b = *(int *)_b;
    int x1,x2;
    if (x[a] < 0)
        x1 = (-3-x[a]) * w[a];
    else x1 = (x[a] - 3) * w[a];
    if (x[b] < 0)
        x2 = (-3-x[b]) * w[b];
    else x2 = (x[b]-3) * w[b];
    return x1 - x2 ;
}

void init()
{
    for (int i = 0 ; i < N ; i++)
    {
        scanf("%d%d",&x[i],&w[i]);
        x[i] *= 2;
    }
}

int dfs(int left,int right,int num)
{
    int k,flag,mleft,mright,tleft=1,tright=1;

    if (num == N)
        return 2;

    for (int i = 0 ; i < N1 ; i++)
    {
        k = r1[i];
        if ( !vis[k] )
        {
            vis[k] = 1 ;
            mleft = left + (3+x[k])*w[k];
            mright = right + (3-x[k])*w[k];
            s[num] = k ;
            if (mleft >= 0)      
                tleft =  0 ;

            if (mleft >= 0 && mright >= 0)
            {
                flag = dfs(mleft,mright,num+1);
                if (flag == 2)      
                    return 2;
                if (flag == -1) //如果再往下放都不成立的话，就别再放左边了
                    break;
            }
            vis[k] = 0 ;
        }
    }

    for (int i = 0 ; i < N2 ; i++)
    {
        k = r2[i];
        if ( !vis[k] )
        { 
            vis[k] = 1 ;
            mleft = left + (3+x[k]) * w[k];
            mright = right + (3-x[k]) * w[k];
            s[num] = k ;
            if (mright >= 0)
                tright = 0;

            if ( mleft >=0 && mright >= 0)
            {
                flag = dfs(mleft,mright,num+1);
                if (flag == 2)
                    return 2 ;
                if (flag == 1 )  // 再放下放都不成立的话，就不再放右边了
                    break;
            }
            vis[k] = 0 ;
        }
    }
    return tright - tleft ;     // 判断并返还这两次放的是否成立，返还零的话，就让它回溯，尝试别的方法
}

void solve()
{
    int left,right,num=0;
    memset(vis,0,sizeof(vis));
    left = right = 3 * M;

    for (int i = 0 ; i < N ; i++)
        if ( x[i] >= -3 && x[i] <= 3)
        {
            s[num++] = i;
            vis[i] = 1 ;
            left += (3 + x[i]) * w[i];
            right +=(3 - x[i]) * w[i];
        }

    N1 = N2 = 0 ;
    for (int i = 0 ; i < N ; i++)
    {
        if ( !vis[i] )
        {
            if ( x[i] < 0)
                r1[N1++] = i ;
            else r2[N2++] = i ;
        }
    }
    
    qsort(r1,N1,sizeof(r1[0]),cmp);
    qsort(r2,N2,sizeof(r2[0]),cmp);

    if ( dfs(left,right,num) != 2 )
        printf("Impossible\n");
    else 
        for (int  i = N-1 ; i >= 0 ; i--)
            printf("%d %d\n",x[s[i]]/2,w[s[i]]);
}

int main()
{
    int t = 0;
    while (scanf("%d%d%d",&L,&M,&N) != EOF )
    {
        if (!L)
            break;
        init();
        printf("Case %d:\n",++t);
        solve();
    }
    return 0;
}