World Finals 2017 (水题题解)

看大佬做2017-WF，我这种菜鸡，只能刷刷水题，勉强维持生活。 赛后补补水题。

题目pdf链接，中文的，tls翻译的，链接在这里

个人喜欢在vjudge上面刷题。

E Need for Speed

题意：

有中文题意，我就不多说了，仪表盘会有一个固定偏差，求这个。

思路：

二分答案，进行判断，二分的上下限，我是 -1 到 1e8；一开始范围错了WA掉了。

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;
typedef long long int LL;
const int INF=2e9+1e8;
const int maxn=1e6+100;
const double eps=1e-8;
int di[maxn],si[maxn],n,T;
bool judge(double mid)
{
    double ans=0;
    for(int i=0; i<n; i++)
    {
        ans+=di[i]/(si[i]+mid);
    }
   // printf("mid=%lf ans=%lf\n",mid,ans);
    return ans>=T;
}
double solve(double l,double r)
{
    double ans=-100000;
    while((l<=r)&&(r-l>eps))
    {
        double mid=(l+r)/2;
        //printf("l=%")
        //  printf("mid=%lf flag=%d\n",mid,judge(mid));
        if(judge(mid)) l=mid;
        else r=mid;
        ans=mid;
    }
    return ans;
}
//#define JJ -0.508653377
int main()
{
    // printf("%lf\n",5/(3+JJ)+2/(2+JJ)+3/(6+JJ)+3/(1+JJ));
    scanf("%d%d",&n,&T);
    int l=INF;
    for(int i=0; i<n; i++)
    {
        scanf("%d%d",&di[i],&si[i]);
        l=min(si[i],l);
    }
    printf("%lf\n",solve(double(-l),100000000.));
    return 0;
}

Problem I ：Secret Chamber at Mount Rushmore

题目描述：

有一组转化关系，如果字符 a->b, b->c, 那么 a->c 也成立。问，给定一些关系，前面的字符串能否转为后面的字符串？ yes：no

题目思路：

一开始预处理出，任意两点是否能到达。枚举每一个起点进行dfs。后面\(O(1)\)查询。

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string.h>
#include <string>
#include <queue>
using namespace std;
typedef long long int LL;
const int INF=2e9+1e8;
const int maxn=1e6+100;
const double eps=1e-8;
struct Node
{
	char t;
	int next;
}edge[maxn];
int first[265],sz;
void init()
{
	memset(first,-1,sizeof(first));
	sz=0;
}
void addedge(char s,char t)
{
	edge[sz].t=t,edge[sz].next=first[(int)s];
	first[(int)s]=sz++;
}
bool maze[265][265];
bool vis[264];
void dfs(int now,int to)
{
	maze[now][to]=1;
	vis[to]=1;
	for(int i=first[to];i!=-1;i=edge[i].next)
	{
		int t=edge[i].t;
		if(vis[t]==0) dfs(now,t);
	}
}
int main()
{
	init();
	int n,m;
	scanf("%d%d",&n,&m);
	for(int i=0;i<n;i++)
	{
		char s[5],t[5];
		scanf("%s%s",s,t);
		addedge(s[0],t[0]);
	}
	memset(maze,0,sizeof(maze));
	for(char i='a';i<='z';i++)
	{
		memset(vis,0,sizeof(vis));
		dfs(i,i);
	}
	while(m--)
	{
		char a[100],b[100];
		int lena,lenb;
		scanf("%s%s",a,b);
		lena=strlen(a),lenb=strlen(b);
		if(lena!=lenb) printf("no\n");
		else
		{
			bool flag=true;
			for(int i=0;i<lena;i++)
			{
				if(maze[(int)a[i]][(int)b[i]]==0)
				{
					flag=false;
					break;
				}
			}
			if(flag) printf("yes\n");
			else printf("no\n");
		}
	}
	return 0;
}

题目链接：C - Mission Improbable

题目意思：

给你一个平面图代表每一个位置的箱子个数，问做多拿走多少个箱子，三视图不变？

解题思路：

看了题解慢慢懂的，问题在于求哪些箱子需要保留下来。才能保证三视图不变。首先我们想俯视图，只需要让有的地方留一个箱子即可。其次，正视图，侧视图。我们可以这样子思考，先不管正视图。我侧视图，选完了再说。那么侧视图需要保留的个数就是每行的最大值减一。

那么现在来考虑正视图。正视图应该如何选择才能使得选择最少并且满足条件？ 如果侧视图选中了正视图的最大值那么正视图就不需要额外再选择。刚好，二分图匹配能解决，我们让二分图左边是行号，右边是列号。当某个位置既是行的最大值又是列的最大值，那么我们就在i行与j列之间建一条边。跑一遍匈牙利算法之后，匹配是最大的，意思就是让尽可能多的行列公用一个元素，之后对于无法公用的列那就让该列选择该列的最大值即可。

弱弱代码，仅供参考。

#include <cstdio>
#include <cstring>
#include <cctype>
#include <cmath>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <stdlib.h>
#include <time.h>
using namespace std;
typedef long long LL;
const int INF = 2e9 + 1e8;
const int MOD = 1e9 + 7;
const double eps = 0.0000000001;
void fre()
{
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
}
#define MSET(a, b) memset(a, b, sizeof(a))
#define fr(i, a, n) for (int i = a; i < n; i++)
const int maxn = 150;
int mat[maxn][maxn];
int side[maxn], front[maxn];
int G[maxn][maxn];
int vis[maxn], link[maxn], n, m;
int match(int x)
{
    for (int i = 1; i <= m; i++)
    {
        if (!vis[i] && G[x][i])
        {
            vis[i] = 1;
            if (!link[i] || match(link[i]))
            {
                link[i] = x;
                return 1;
            }
        }
    }
    return 0;
}
int main()
{
    scanf("%d%d", &n, &m);
    LL sum = 0, sub = 0;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            scanf("%d", &mat[i][j]);
            side[i] = max(side[i], mat[i][j]);
            front[j] = max(front[j], mat[i][j]);
            if (mat[i][j])
                sub++;
            sum += mat[i][j];
        }
    }
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            if (mat[i][j] && side[i] == front[j])
                G[i][j] = 1;
        }
    }
    for (int i = 1; i <= n; i++)
    {
        memset(vis, 0, sizeof(vis));
        match(i);
    }//匹配
    for (int i = 1; i <= n; i++)
        if (side[i])
            sub += side[i] - 1; //统计侧视图
    for (int i = 1; i <= m; i++)
        if (!link[i] && front[i])
            sub += front[i] - 1; //把没匹配的额外加；
    printf("%lld\n", sum - sub);
    return 0;
}

--------- D - Money for Nothing -------------

题目描述：

2017 World Final D,原本的题意就不说，我转化一下就是。给定两个点的集合set:\(A\);set:\(B\),任意在两个集合中各选一个，求最大的 \(max\left ( \left ( x_B - x_A \right )\times \left ( y_B-y_A \right ) \right )\);再和0取一下最大值（即为：最大值为负数输出0）。

解题思路：

参见了大佬的解法，可以把A集合的点和B集合的点都描在二维坐标系中。我们可以很容易发现，A集合中x相同的尽量取y小的，B集合中x相同的尽量取y较大的。那么我们可以将集合A按照 x的递增且y的递增 进行排序。那么我们从前往后遍历y只有变小才有可能比前一个的答案更优。否则就没意义，不保留那个元素。

对于集合B来讲，我们也对B集合按照A集合的方式进行排序。因为我们需要尽量y大的数，我们可以从后往前遍历，只有y变大了才可能更优；处理完后我们得到的A，B集合都是x严格递增y严格递减的序列；

根据官方题解：

假设P代表一个点，\(i < j\),\(P_i , P_j\)是A集合的点，\(k < l\),\(P_k , P_l\)是B集合的元素，我们定义\(f\left ( x,y\right )\)代表y点为右上角，x为左下角这个对角线所构成的矩形面积。画图可验证一个结论:

\(f\left ( i,k\right )+f\left ( j,l \right )\geq f\left ( i,l\right )+f\left ( j,k \right )\)

这个结论告诉我们，A集合中每个点的最优的与B的连线不会有相交除了端点处。有了这个结论分治法就可以解。

不知道如何分治，看这里。分治，快排算法类似的，选A集合中间的位置，找到A的最优解位置，以这个位置将原来的集合分为两个。再解决。具体看代码一目连然。

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <string>
using namespace std;
typedef long long int LL;
#define MSET(a,b) memset(a,b,sizeof(a))
const int maxn=1e6+10;
struct Point
{
    int x,y;
}A[maxn],B[maxn],T[maxn];
bool cmp(Point a,Point b) //x递增，y递增
{
    if(a.x!=b.x) return a.x <b.x;
    return a.y<b.y;
}
LL ans;
int dp[maxn];
void dfs(int l,int r,int L,int R)
{
    if(l>r||A[r].y>=B[L].y||A[l].x>=B[R].x) return ;
    int mid=(l+r)>>1,pos=0;
    int s=lower_bound(dp+L,dp+R+1,A[mid].x)-dp;
    LL mx=0;
    for(int i=s;i<=R;i++)
    {
        if(B[i].y<=A[mid].y) break;
        LL val=1ll*(B[i].y-A[mid].y)*(B[i].x-A[mid].x);
        if(val>mx) mx=val,pos=i;
        //if(val>ans) ans=val,pos=i;
    }
    ans=max(ans,mx);
    if(pos) dfs(l,mid-1,L,pos),dfs(mid+1,r,pos,R);
    else dfs(l,mid-1,L,R),dfs(mid+1,r,L,R);
}
int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)+1)
    {
        for(int i=1;i<=n;i++) scanf("%d%d",&A[i].x,&A[i].y);
        for(int i=1;i<=m;i++) scanf("%d%d",&T[i].x,&T[i].y);
        sort(A+1,A+1+n,cmp);
        sort(T+1,T+1+m,cmp);
        int ia=1,ib=1;
        A[1]=A[1],B[1]=T[m];
        for(int i=2;i<=n;i++)
            if(A[i].y<A[ia].y) A[++ia]=A[i];
        for(int i=m-1;i>0;i--)
            if(T[i].y>B[ib].y) B[++ib]=T[i];
        reverse(B+1,B+1+ib);
        for(int i=1;i<=ib;i++) dp[i]=B[i].x;
        // for(int i=1;i<=ia;i++)
        //     printf(">>> %d %d\n",A[i].x,A[i].y);
        // for(int i=1;i<=ib;i++)
        //     printf(">>> %d %d\n",B[i].x,B[i].y);
        ans=0;
        dfs(1,ia,1,ib);
        printf("%lld\n",ans);
    }
    return 0;
}

--------- F - Posterize -------------

题目描述：

就是求那个给出的公式，只考虑红色0-255像素值，给出每个颜色的像素点个数，要求把这些像素点变为最多k种像素值。求\(\sum _{i=1}^{n} \underset{1\leqslant i\leqslant k}{min}\left ( r_i-v_j\right )^2\)。每个像素原来的颜色与现在和它绝对值最小的元素的差值平方求和

解题思路：

dp的思想，0-255，时间复杂度：\(O(n^3)\)都可以，所以我们设 dp[i][j] :表示颜色分布0-i，变为最多j种颜色的答案。fx[i][j]:表示将颜色区间[i,j] 的颜色变为同样的某一种颜色的最小值。那么转移方程\(dp(i,j)=\underset{0\leq k\leq i}{min}(dp(k,j-1)+f(k+1,i))\)

code :

#include <cstdio>
#include <cstring>
#include <cctype>
#include <cmath>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <stdlib.h>
#include <time.h>
using namespace std;
typedef long long LL;
const int INF = 2e9 + 1e8;
const int MOD = 1e9 + 7;
const double eps = 0.0000000001;
void fre()
{
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
}
#define MSET(a, b) memset(a, b, sizeof(a))
#define fr(i, a, n) for (int i = a; i < n; i++)
const int maxn = 300;
LL fx[maxn][maxn], dp[maxn][maxn];
int red[maxn];
void Min(LL &x, LL t)
{
    if (t < x)
        x = t;
}
int main()
{
    int n, k;
    scanf("%d%d", &n, &k);
    MSET(dp, 0x7f);
    MSET(fx, 0x7f);
    for (int i = 1; i <= n; i++)
    {
        int r, p;
        scanf("%d%d", &r, &p);
        red[r] = p;
    }
    for (int color = 0; color <= 255; color++)
    {
        for (int l = 0; l <= 255; l++)
        {
            LL num = 0;
            for (int r = l; r <= 255; r++)
            {
                num += 1ll * (r - color) * (r - color) * red[r];
                Min(fx[l][r], num);
            }
        }
    }
    //处理出，f[l][r];代表区间 l，r；
    for (int i = 0; i <= 255; i++)
        dp[i][1] = fx[0][i];
    for (int i = 0; i <= 255; i++)
        for (int j = 2; j <= k; j++)
            for (int t = 0; t < i; t++)
                Min(dp[i][j], dp[t][j - 1] + fx[t + 1][i]);
    cout << dp[255][k] << endl;
    return 0;
}