枚举

一.枚举算法
1.对问题可能解集合的每一项
2.根据问题给定的检验条件判定哪些是成立的
3.使条件成立的即是问题的解

二.枚举中三个关键问题
1.问题一：给出解空间，建立简洁的数学模型，可能的情况是什么，模型中变量数尽可能少，它们之间相互独立
(“求小于N的最大素数” 中的条件是 “n不能被[2,n)中任意一个素数整除”而不是 “n不能被[2,n)中任意一个整数整除”)

2.问题二：减少搜索的空间，利用知识缩小模型中各变量的取值范围， 避免不必要的计算，减少代码中循环体执行次数

(除2之外, 只有奇数才可能是素数, {2,2*i+1|1<=i, 2*i+1<n})

3.问题三：采用合适的搜索顺序，搜索空间的遍历顺序要与模型中条件表达式一致
(对{2,2*i+1|1<=i, 2*i+1<n}按照从小到大的顺序)

 三.百钱百鸡问题

鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一，百钱买百鸡，问鸡翁，鸡母，鸡雏各几何
求解方法:
1.先构造可能的解的集合 S={(X,Y,Z)|0<=X<=20,0<=Y<=33,Z=100-X-Y}(X, Y, Z分别代表买公鸡, 母鸡和小鸡的只数)
2.然后验证条件X+Y+Z=100, 5X+3Y+Z/3=100

#include<iostream>
using namespace std;

int main()
{
    for (int x = 0; x <= 20; x++)
    {
        for (int y = 0; y <= 33; y++) 
        {
            int z = 100 - x - y;
            if (z % 3 == 0)
            {
                if (5 * x + 3 * y + z / 3 == 100)
                {
                    cout << x << " " << y << " " << z << endl;
                }
            }
        }
    }
}

 

四.熄灯问题
1.问题描述：
有一个由按钮组成的矩阵, 其中每行有6个按钮, 共5行。每个按钮的位置上有一盏灯

 
当按下一个按钮后, 该按钮以及周围位置(上边, 下边, 左边, 右边)的灯都会改变一次，如果灯原来是点亮的, 就会被熄灭，如果灯原来是熄灭的, 则会被点亮。

2.解题分析：
(第2次按下同一个按钮时, 将抵消第1次按下时所产生的结果，每个按钮最多只需要按下一次，各个按钮被按下的顺序对最终的结果没有影响
对第1行中每盏点亮的灯, 按下第2行对应的按钮, 就可以熄灭第1行的全部灯，如此重复下去, 可以熄灭第1, 2, 3, 4行的全部灯)

枚举所有可能的按钮(开关)状态, 对每个状态计算一下最后灯的情况, 看是否都熄灭。每个按钮有两种状态(按下或不按下)一共有30个开关, 那么状态数是230, 太多, 会超时如何减少枚举的状态数目呢？

基本思路: 如果存在某个局部, 一旦这个局部的状态被确定，那么剩余其他部分的状态只能是确定的一种，或者不多的n种，那么就只需枚举这个局部的状态即可。
本题是否存在这样的 “局部” 呢?经过观察，发现第1行就是这样的一个 “局部”
因为第1行的各开关状态确定的情况下，这些开关作用过后，将导致第1行某些灯是亮的，某些灯是灭的要熄灭第1行某个亮着的灯(假设位于第i列), 那么唯一的办法就是按下第2行第i列的开关(因为第1行的开关已经用过了, 而第3行及其后的开关不会影响到第1行)为了使第1行的灯全部熄灭, 第2行的合理开关状态就是唯一的。第2行的开关起作用后，为了熄灭第2行的灯, 第3行的合理开关状态就也是唯一的。以此类推, 最后一行的开关状态也是唯一的只要第1行的状态定下来, 记作A, 那么剩余行的情况就是确定唯一的了。
用一个6*8的数组来表示按钮矩阵:
简化计算数组下一行的值的计算公式，第0行, 第0列和第7列不属于PRESS矩阵范围, 可全置0

#include <stdio.h>
int puzzle[6][8];//灯的初始状态
int press[6][8];//要计算的结果,1表示按下按钮
bool guess(){
    int c, r;
    for(r=1; r<5; r++)
        for(c=1; c<7; c++)
            press[r+1][c] = (puzzle[r][c]+press[r][c]+
            press[r-1][c]+ press[r][c-1]+press[r][c+1]) %2;
    for(c=1; c<7; c++)
        if ((press[5][c-1] + press[5][c] + press[5][c+1] +
            press[4][c]) %2 != puzzle[5][c] )
            return(false);
    return(true);
}
void enumerate (){
    int c;
    bool success;
    for ( c=1; c<7; c++)
        press[1][c] = 0;
    while(guess()==false){
        press[1][1]++;
        c = 1;
        while (press[1][c] > 1) {
            press[1][c] = 0;
            c++;
            press[1][c]++;
        }
    }
    return;
}
int main() {
    int cases, i, r, c;
    scanf("%d", &cases);
    for ( r=0; r<6; r++ )
        press[r][0] = press[r][7] = 0;
    for ( c=1; r<7; r++ )
        press[0][c] = 0;
    for (i=0; i<cases; i++){
        for(r=1; r<6; r++)
            for(c=1; c<7; c++)
                scanf("%d", &puzzle[r][c]);
        enumerate();
        printf("PUZZLE #%d\n", i+1);
        for(r=1; r<6; r++){
            for(c=1; c<7; c++)
                printf("%d ", press[r][c]);
            printf("\n");
        }
    }
    return 0;
}

五.讨厌的青蛙
1.问题描述：有一种小青蛙，每到晚上，这种青蛙会跳跃稻田，从而踩踏稻子。农民早上看到被踩踏的稻子，希望找到造成最大损害的那只青蛙经过的路径每只青蛙总是沿着一条直线跳跃稻田且每次跳跃的距离都相同。

稻田里的稻子组成一个栅格, 每棵稻子位于一个格点上，而青蛙总是从稻田的一侧跳进稻田, 然后沿着某条直线穿越稻田, 从另一侧跳出去

可能会有多只青蛙从稻田穿越，青蛙每一跳都恰好踩在一棵水稻上, 将这棵水稻拍倒。有些水稻可能被多只青蛙踩踏，农民所见到的是右图中的情形, 并看不到左图中的直线，也见不到别人家田里被踩踏的水稻。

2.解题思路 — 枚举
枚举每个被踩的稻子作为行走路径起点 (5000个)，对每个起点, 枚举行走方向 (5000种)，对每个方向枚举步长 (5000种)，枚举步长后还要判断是否每步都踩到水稻，时间: 5000*5000*5000 * , 不行!
每条青蛙行走路径中至少有3棵水稻，假设一只青蛙进入稻田后踩踏的前两棵水稻分别是(X1,Y1),(X2,Y2)。那么青蛙每一跳在 X 方向上的步长 dX = X2 - X1，在 Y 方向上的步长 dY = Y2 - Y1;
(X1 – dX, Y1 - dY) 需要落在稻田之外；当青蛙踩在水稻(X, Y)上时, 下一跳踩踏的水稻是(X + dX, Y + dY)；将路径上的最后一棵水稻记作(XK, YK), (XK + dX, YK + dY)需要落在稻田之外; 11
猜测(X1, Y1), (X2, Y2) -- 所要寻找的行走路径上的前两棵水稻当下列条件之一满足时, 这个猜测就不成立：
• 青蛙不能经过一跳从稻田外跳到(X1, Y1)上
• 按照(X1, Y1), (X2, Y2)确定的步长, 从(X1, Y1)出发, 青蛙最多经过(MAXSTEPS - 1)步, 就会跳到稻田之外MAXSTEPS是当前已经找到的最好答案

 

#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
using namespace std;
int r, c, n;
struct PLANT {
    int x, y;
};
PLANT plants[5001];
PLANT plant;
int searchPath(PLANT secPlant, int dX, int dY) ;

int main()
{
    int i, j, dX, dY, pX, pY, steps, max = 2;
    scanf("%d %d", &r, &c);
    //行数和列数, x方向是上下, y方向是左右
    scanf("%d", &n);
    for (i = 0; i < n; i++)
        scanf("%d %d", &plants[i].x, &plants[i].y);
    //将水稻按x坐标从小到大排序, x坐标相同按y从小到大排序
    sort(plants, plants + n);
    for (i = 0; i < n - 2; i++) //plants[i]是第一个点
        for ( j = i + 1; j < n -1 ; j++) { //plants[j]是第二个点
            dX = plants[ j ].x - plants[i].x;
            dY = plants[ j ].y - plants[i].y;
            pX = plants[ i ].x - dX;
            pY = plants[ i ].y - dY;
            if (pX <= r && pX >= 1 && pY <= c && pY >= 1)
                continue;
            //第一点的前一点在稻田里,
            //说明本次选的第二点导致的x方向步长不合理(太小)
            // 取下一个点作为第二点
            if (plants[ i ].x + (max - 1) * dX > r)
                break;
            //x方向过早越界了. 说明本次选的第二点不成立
            //如果换下一个点作为第二点, x方向步长只会更大, 更不成立, 所以应该
            //认为本次选的第一点必然是不成立的, 那么取下一个点作为第一点再试
                pY = plants[ i ].y + (max - 1) * dY;
            if ( pY > c || pY < 1)
                continue; //y方向过早越界了, 应换一个点作为第二点再试
            steps = searchPath(plants[ j ], dX, dY);
            //看看从这两点出发, 一共能走几步
            if (steps > max) max = steps;
        }
        if ( max == 2 ) max = 0;
        printf("%d\n", max);
}
bool operator < ( const PLANT & p1, const PLANT & p2)
{
    if ( p1.x == p2.x )
        return p1.y < p2.y;
    return p1.x < p2.x ;
} 
//判断从 secPlant点开始, 步长为dx, dy, 那么最多能走几步
int searchPath(PLANT secPlant, int dX, int dY){
    PLANT plant;
    int steps;
    plant.x = secPlant.x + dX;
    plant.y = secPlant.y + dY;
    steps = 2;
    while (plant.x <= r && plant.x >= 1 && plant.y <= c && plant.y >= 1) {
        if (! binary_search(plants, plants + n, plant)) {
            //每一步都必须踩倒水稻才算合理, 否则这就不是一条行走路径
            steps = 0;
            break;
        }
        plant.x += dX;
        plant.y += dY;
        steps++;
    }
    return(steps);
}

 

 

13