二分答案 & 三分法

        二分法是竞赛中常用的一种降低时间复杂度的方法，其中二分答案是竞赛中常用的算法。它的使用范围较为明确，无非就是两种情况。

        1.求方程……=……的根 （仅能求出少量的根，较广泛适用于完全单调递增或递减的方程中）

        2.求某种情况的最大最小值或最小最大值

 

        二分答案的模板也非常简单，基本上所有的二分答案主程序代码如下：

 

        while (right-left > eps)
        {
            int mid = (left+right)/2;
            if (solve(mid)) right = mid;
            else left = mid;
        }

         那么，既然二分答案思想简单，为何要进行总结呢？首先我们应该明确，二分答案的难点并不在于它的思想，而在于那个solve（）函数

        下面看几道例题：

UVa 10341 Solve it！

        解方程 p*e^(-x)+q*sin(x)+r*cos(x)+s*tan(x)+t*x^2+u=0,其中x∈[0,1]。输入p,q,r,s,t;

        很简单的一道二分求根法，f(x)=p*e^(-x)+q*sin(x)+r*cos(x)+s*tan(x)+t*x^2+u在x∈[0,1]时严格递增，可用勘根定理来求解，solve函数即为f(x) 的值，核心代码如下：

 

double solve(double x)
{
	return p*exp(-x)+q*sin(x)+r*cos(x)+s*tan(x)+t*x*x+u;
}

if (solve(0)*solve(1) > 0) printf("No solution!\n");
else
{	
	while (right-left > eps)
	{
		double mid = (right+left)/2;
		if (solve(left)*solve(mid) < 0) right = mid;
		else left = mid;
	}
}

 

P.S.：基本上所有的判根都可以使用以上的代码，唯一不同的就是它的solve函数还有初始left值与right值。

 

UVa 11090 Going in Cycle!!

        给定一个n个点m条边的加权有向图，求平均权值最小的回路。

        平均权值的出现似乎令我们吓了一跳，因为平时只接触过最短或最长。但由于题目中给出的是回路，又是求路径，不难想到和负权回路有关系。于是我们猜测存在一个平均权值小于mid的回路，这条回路上的各条边的权值分别为w1,w2,w3......wk，则w1+w2+......wk<k*mid，即(w1-mid)+(w2-mid)+......(wk-mid)<0，负权回路！

       于是我们可以将所有的边减去mid，在判断有没有负权回路即可。

核心代码如下：

#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

const int MAXN=1001;
const int INF=100000;
const double eps = 1e-4;

struct Node
{
    int to;
    double dist;
};

int n,m;
double dist[MAXN];//离源点的最短距离 
int cnt[MAXN]; //判断是否存在负权回路 
bool inq[MAXN];//是否在队列中 
vector <Node> G[MAXN];

bool SPFA(int s)
{
    for (int i=1;i<=n;i++) dist[i]=INF;
    memset(inq,false,sizeof(inq));
    dist[s] = 0;inq[s] = true;
    queue <int> Q;
    Q.push(s);
    while (!Q.empty())
    {
        int x=Q.front();Q.pop();
        inq[x]=false;
        for (int i=0;i<G[x].size();i++)
            if (dist[x]+G[x][i].dist<dist[G[x][i].to])
            {
                dist[G[x][i].to]=dist[x]+G[x][i].dist;
                if (!inq[G[x][i].to])
                {
                    Q.push(G[x][i].to);
                    inq[G[x][i].to]=true;
                    if (++cnt[G[x][i].to] > n) return true;
                }
            }
    } 
    return false;
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
    {
        int from,to,dist;
        scanf("%d%d%d",&from,&to,&dist);
        G[from].push_back((Node){to,dist});        
    }
    double left = 0, right = 10000;
    bool a= SPFA(1);
    while (right-left > eps)
    {
        double mid = (right+left)/2;
        for (int i=1;i<=n;i++)
            for (int j=0;j<G[i].size();j++) G[i][j].dist -= mid;
        bool Negative_Ctyle = SPFA(1);
        for (int i=1;i<=n;i++)
            for (int j=0;j<G[i].size();j++) G[i][j].dist += mid;
        if (Negative_Ctyle) right = mid;
        else left = mid;
    }
    printf("%lld\n",left);
    return 0;
} 

LA 4254

        本题也是一题经典的最大最小值，它的解法很简单，就是二分枚举速度，看以目前速度处理器是否可以解决。于是所有的难点就是这个solve（）函数。其实我们可以以贪心的做法，将结束时间早的尽快处理，代码中使用了优先队列来维护操作，也可以使用线段树进行维护，代码如下：

#include <cstdio>
#include <cstring>
#include <cmath>
#include <queue>
#include <algorithm>

using namespace std;

const int MAXN = 10001;
const int INF = 10000001;

struct Node
{
    double r,d,w;
    bool operator < (const Node &x) const
    {
        return d > x.d;
    }
} data[MAXN];

int n,t;

bool cmp(Node x,Node y)
{
    return x.r < y.r;
}

bool solve(int speed)
{
    priority_queue <Node> Heap;
    double now_time = data[1].r;
    for (int i=1;i<=n;i++)
    {
        now_time = max(now_time,data[i].r);
        Heap.push(data[i]);
        while (now_time < data[i+1].r && !Heap.empty())
        {
            Node x = Heap.top();Heap.pop();
            if (x.d < now_time+(x.w/speed)) return false;
            if ((double)x.w/speed <= (data[i+1].r-now_time)) now_time += (double)x.w/speed;
            else 
            {
                x.w -= speed*(data[i+1].r-now_time);
                Heap.push(x);
                now_time = data[i+1].r;
            }
        }
    }
    return true;
}

int main()
{
    scanf("%d",&t);
    while (t--)
    {
        scanf("%d",&n);
        memset(data,0,sizeof(data));
        for (int i=1;i<=n;i++) scanf("%lf%lf%lf",&data[i].r,&data[i].d,&data[i].w);
        int min_speed = 0, max_speed = 1000001;
        data[n+1].r = INF;
        sort(data+1,data+n+1,cmp);
        while (min_speed+1 != max_speed)
        {
            int mid = (min_speed+max_speed)/2;
            if (solve(mid)) max_speed = mid;
            else min_speed = mid;
        }
        printf("%d\n",max_speed);
    }
    return 0;
}

 

        三分法是后来加上去的，因为其性质与二分法差不多，我们姑且把它们归为同类的算法，三分法有什么用呢？求一个单峰函数的最值。

        什么叫做单峰函数，根据高中数学4-7定义，函数f(x)在[a,b]上有唯一最值点C，且在C的左边与右边都严格单调递增或递减，那么称这个函数在[a,b]间为单峰函数。

        三分法求最值过程很简单，这里就不细讲了，仅仅贴出代码：

while (r-l > eps)
{
    double mid1 = l+(r-l)/3;
    double mid2 = r-(r-l)/3;
    if (f(mid1) < f(mid2)) r = mid2; else l = mid1; 
}

 

 

后记：
        二分的作用其实不止这些，实际上，倍增算法（将时间复杂度为O(N)降为O(log N)）运用二分的思想在各种算法中广泛应用。下面给出几道二分答案的题目。

        UVa 10382