POJ - 1054 The Troublesome Frog 模拟 枚举优化。

题意：有个R*C的格网。上面有若干个点，这些点可以连成一些直线，满足：这些点在直线上均匀排布（也就是间隔相等），直线的两段穿过网格（也就是第一个，最后一个在网格的边界附近）

求某条直线上最多的点数

题解：先排序，再任取两个水稻，算出之间的dx,dy,然后就能推出前后的水稻坐标，用如果满足路径上一直有水稻(用binarysearch），且第一个点与最后一个点在水稻外面，就是一个可行的解，维护其最大值。

注意一些判断。

ac代码：

#include<iostream>
#include<algorithm>
#define _for(i,a,b) for(int i=(a);i<(b);i++)
using namespace std;
const int maxn = 5e3 + ;
struct plant {
    int x, y;
    bool operator <(const plant b)const { return this->x == b.x ? this->y < b.y : this->x < b.x; }
    //bool operator ==(const plant b)const { return this->x == b.x&&this->y == b.y; }
}p[maxn];
int c, r;
int n;
int dx, dy, px, py,mx=,steps;
int searchPath(plant p1, int dx, int dy) {
    plant dp;
    dp.x = p1.x + dx;
    dp.y = p1.y + dy;
    int steps =;
    while (dp.x <= r&&dp.x >=  && dp.y <= c&&dp.y >= ) {
        if (!binary_search(p, p + n, dp)) {steps = ; break;}
        dp.x += dx;
        dp.y += dy;
        steps++;
    }
    return steps;
}
int main() {

    cin >> r >> c;

    cin >> n;
    _for(i, , n) {
        cin >> p[i].x >> p[i].y;
    }
    sort(p, p + n);
    _for(i, , n - )_for(j, i + , n - ) {
        dx = p[j].x - p[i].x;
        dy = p[j].y - p[i].y;
        px = p[i].x -dx;
        py = p[i].y -dy;
        if (px <= r&&px >=  && py <= c&&py >= )continue;
        if (p[i].x + (mx - )*dx > r)break;//已经是最小dx了，这都不满足，直接换第一个点
        if (p[i].y + (mx - )*dy > c|| p[i].y + (mx - )*dy < )continue;//dy并不递增，也可能小于0
        steps = searchPath(p[j], dx, dy);
        mx = max(mx, steps);
    }
    cout << (mx ==  ? :mx);
}