JZOJ2137.2017.05.20【usaco2017_Mar Bronze & Silver】C组T5Bovine Genomics

题目描述

Farmer John owns N cows with spots and N cows without spots. Having just completed a course in bovine genetics, he is convinced that the spots on his cows are caused by mutations in the bovine genome.

At great expense, Farmer John sequences the genomes of his cows. Each genome is a string of length Mbuilt from the four characters A, C, G, and T. When he lines up the genomes of his cows, he gets a table like the following, shown here for N=3:

Positions: 1 2 3 4 5 6 7 … M

Spotty Cow 1: A A T C C C A … T
Spotty Cow 2: G A T T G C A … A
Spotty Cow 3: G G T C G C A … A

Plain Cow 1: A C T C C C A … G
Plain Cow 2: A G T T G C A … T
Plain Cow 3: A G T T C C A … T

Looking carefully at this table, he surmises that positions 2 and 4 are sufficient to explain spottiness. That is, by looking at the characters in just these two positions, Farmer John can predict which of his cows are spotty and which are not (for example, if he sees G and C, the cow must be spotty).

Farmer John is convinced that spottiness can be explained not by just one or two positions in the genome, but by looking at a set of three distinct positions. Please help him count the number of sets of three distinct positions that can each explain spottiness.

输入

The first line of input contains N (1≤N≤500) and M (3≤M≤50). The next N lines each contain a string of M characters; these describe the genomes of the spotty cows. The final N lines describe the genomes of the plain cows.

输出

Please count the number of sets of three distinct positions that can explain spottiness. A set of three positions explains spottiness if the spottiness trait can be predicted with perfect accuracy among Farmer John’s population of cows by looking at just those three locations in the genome.

样例输入

3 8
AATCCCAT
GATTGCAA
GGTCGCAA
ACTCCCAG
ACTCGCAT
ACTTCCAT

样例输出

22

数据范围限制

译文：
题目描述
农民约翰拥有N点奶牛和奶牛没有斑点。刚刚完成了牛遗传学的课程，他确信牛的斑点是由牛基因组的突变引起的。
在巨大的开支，农民约翰测序他的牛的基因组。每个基因组是一个字符串的长度从四mbuilt字符A，C，G，T的时候，他行了他的牛的基因组，他得到一个表像的下面，此处显示的为N = 3：
岗位：2人3人4人6人5人7人…M
斑点母牛1：一一吨C…T
斑点母牛2：G一个…一
斑点母牛3：G * T * C…一
普通奶牛1：一个C…G
普通奶牛2：一只…T
普通奶牛3：一只…T
仔细地看这张桌子，他推测，位置2和4都足以说明有斑点。也就是说，通过看在这两个位置的字符，农民约翰可以预测他的牛是斑点，哪些是不（例如，如果他看到G和C，牛必须斑点）。
农民约翰相信有斑点可以解释不只是一个或两个位置在基因组中，但看着一组三个不同的位置。请帮他算三个不同的位置，都可以解释有斑点集数。
输入
输入的第一行包含N（1≤N≤500）和M（3≤M≤50）。接下来的N行每个字符包含一个字符串；这些描述了斑点奶牛的基因组。最后N行描述了普通奶牛的基因组。
输出
请计算三个不同的位置，可以解释有斑点集数。三个一组的位置说明有斑点如果有斑点的特质可以完美的精确度奶牛的农民约翰的人群，看着那三的位置，在基因组中预测。
样例输入
3 8
aatcccat
gattgcaa
ggtcgcaa
actcccag
actcgcat
acttccat
样例输出
二十二
数据范围限制

思路：
和T2不太一样了
T2是求有多少个位置满足条件，这道是求有几个三元组满足条件
正解是暴力，但有的暴力不一定能过

这是TLE80分的暴力：
代码：

var
        cow:array[0..1000]of string;
        n,m,i,j,k,ans:longint;
procedure solve(x,y,z:longint);
var
        i,j:longint;
        flag:boolean;
        x1,x2,x3:char;
begin
        for i:=1 to n do
        for j:=n+1 to 2*n do
        begin
                if (cow[i][x]=cow[j][x])and(cow[i][y]=cow[j][y])
                and(cow[i][z]=cow[j][z])then exit;
        end;
        inc(ans);
end;
begin
        assign(input,'cownomics.in');reset(input);
        assign(output,'cownomics.out');rewrite(output);
        readln(n,m);
        for i:=1 to 2*n do readln(cow[i]);
        for i:=1 to m do
        for j:=i+1 to m do
        for k:=j+1 to m do
        solve(i,j,k);
        writeln(ans);
        close(input);close(output);
end.

不用想也知道为什么超时：循环大坑

那么怎么用暴力AC本题？
从上面发现，i，j，k三个循环是不可以缺少的
但是有一个1~500循环可以优化
怎么优化？
用一个now数组，记录是否出现过一种方案
省去原先1~500循环的方法是，只用一个1~500循环，同时now记录一下以前是否出现过某种相同的方案，就可以了
提示到这里，应该很好做了
看不懂，我也没办法了，因为我说的已经算很清楚了

代码：

var
        now:array[0..1000]of longint;
        a,b:array[0..1000,0..50]of longint;
        n,m,i,j,k,l,c,d,ans:longint;
        bz:boolean;
        ch:char;
function change(ch:char):longint;
begin
        if ch='A' then exit(1);
        if ch='C' then exit(2);
        if ch='G' then exit(3);
        if ch='T' then exit(4);
end;
procedure readin;
begin
        assign(input,'cownomics.in');reset(input);
        assign(output,'cownomics.out');rewrite(output);
        readln(n,m);
        for i:=1 to n do
        begin
                for j:=1 to m do
                begin
                        read(ch);
                        a[i,j]:=change(ch);
                end;
                readln;
        end;
        for i:=1 to n do
        begin
                for j:=1 to m do
                begin
                        read(ch);
                        b[i,j]:=change(ch);
                end;
                readln;
        end;
end;
begin
        readin;
        for i:=1 to m-2 do
        begin
                for j:=i+1 to m-1 do
                begin
                        for k:=j+1 to m do
                        begin
                                bz:=true;
                                fillchar(now,sizeof(now),0);
                                for l:=1 to n do
                                begin
                                        c:=a[l,i]*100+a[l,j]*10+a[l,k];
                                        d:=b[l,i]*100+b[l,j]*10+b[l,k];
                                        if now[c]=0 then
                                                now[c]:=1
                                        else if now[c]=2 then
                                        begin
                                                bz:=false;
                                                break;
                                        end;
                                        if now[d]=0 then
                                                now[d]:=2
                                        else if now[d]=1 then
                                        begin
                                                bz:=false;
                                                break;
                                        end;
                                end;
                                if bz then inc(ans);
                        end;
                end;
        end;
        writeln(ans);
end.