UVA

题意比较坑，移动完以后的士兵不能再次移动，不然样例都过不了。。。

最小值最大满足决策单调性所以二分答案，跑网络流验证是否可行。

这种题重点在建图，为了保证只移动一次，拆点，一个入点一个出点，到了出点的自然不能再次调度。

不在边界上的边连一条容量为1的边表示至少留一个人，在边界上的与T的连边就设置成mid。

其他细节：

注意二分答案的时候如果是l=mid+1,r=mid这样的(l+r)/2向下取整，

l=mid,r=mid-1则(l+r)/2向上取整，否则遇到如r = l+1判断后执行l = mid这种情况就会死循环。

一开始我想直接把不再边界上的流量减一，但是这样做相当与强行把当前位置往T流了1，实际上它的1不必由它本身提供

，移动完以后的士兵不能再次移动，那么能往边界上的流量可能会减少，除非移动完以后的士兵能再次移动这样才是对的。题意坑啊。。。

#include<bits/stdc++.h>
using namespace std;

const int maxn = 105<<1;
int a[maxn],n;

struct Edge
{
    int v,cap,flow,nxt;
};

vector<Edge> edges;
#define PB push_back
int head[maxn];

void AddEdge(int u,int v,int c)
{
    edges.PB({v,c,0,head[u]});
    head[u] = edges.size()-1;
    edges.PB({u,0,0,head[v]});
    head[v] = edges.size()-1;
}

const int INF = 0x3f3f3f3f;
int S,T,cur[maxn],q[maxn],d[maxn];

bool bfs()
{
    memset(d,0,sizeof(d));
    int l = 0,r = 0;
    q[r++] = S; d[S] = 1;
    while(r>l){
        int u = q[l++];
        for(int i = head[u]; ~i; i = edges[i].nxt){
            Edge &e = edges[i];
            if(!d[e.v] && e.cap>e.flow){
                d[e.v] = d[u]+1;
                q[r++] = e.v;
            }
        }
    }
    return d[T];
}

int dfs(int u,int a)
{
    if(u == T||!a) return a;
    int flow = 0,f;
    for(int &i = cur[u]; ~i; i = edges[i].nxt){
        Edge &e = edges[i];
        if(d[e.v] == d[u]+1 && (f = dfs(e.v,min(e.cap-e.flow,a)))){
            flow += f; a -= f;
            e.flow += f; edges[i^1].flow -= f;
            if(!a) break;
        }
    }
    return flow;
}

int MaxFlow()
{
    int flow = 0;
    while(bfs()){
        memcpy(cur,head,sizeof(head));
        flow += dfs(S,INF);
    }
    return flow;
}

vector<int> Change;

void init()
{
    edges.clear();
    Change.clear();
    memset(head,-1,sizeof(head));
}



void rebuild(int cap)
{
    for(int i = 0; i < edges.size(); i++){
        edges[i].flow = 0;
    }
    for(int i = 0; i < Change.size(); i++){
        edges[Change[i]].cap = cap;
    }
}

int main()
{
    //freopen("in.txt","r",stdin);
    int Test; scanf("%d",&Test);
    while(Test--){
        scanf("%d",&n);
        init();
        S = n<<1; T = S|1;
        int l = 1,r = 0;
        for(int i = 0; i < n; i++){
            scanf("%d",a+i); r += a[i];
        }
        char str[maxn];
        int cnt = 0,sum = 0;
        for(int i = 0; i < n; i++){
            scanf("%s",str);
            if(!a[i]) continue;

            bool border = false;
            for(int j = 0; j < n; j++){
                if(str[j] == 'Y'){
                    if(a[j])
                        AddEdge(i,j+n,INF);
                    else
                        border = true;
                }
            }
            AddEdge(S,i,a[i]);
            AddEdge(i,i+n,INF);
            if(border) Change.PB(edges.size()),AddEdge(i+n,T,0),cnt++;
            else AddEdge(i+n,T,1),sum++;
        }
        int mid;
        for(; l < r; sum + mid*cnt == MaxFlow()? l = mid:r = mid-1)
            mid = (l+r+1)>>1,rebuild(mid);//l = mid.上取整 l = mid+1 下取整
        printf("%d
",l);
    }
    return 0;
}