从现在开始每周写一个总结报告，至少包括5题，难度适中即可。
【1】Vijos P1022 Victoria的舞会2
题目链接https://vijos.org/p/1022
本质上就是求强连通分支的数目，可以采用floyd算法根据题目中的传递特征求出有向图的矩阵表示，然后再用贪心法求出强连通分支的数目。运行时间基本都在30ms左右，个人感觉效率偏低，但目前还没想到其他更好的办法。
#include <iostream>
#include <algorithm>
#include <queue>
#include <string.h>
using namespace std;
int main(){
int n;
bool check[201][201];
memset(check, false, sizeof(check));
cin>>n;
for(int i=0; i<n; i++){
int tmp;
while(cin>>tmp && tmp)
check[i][tmp-1] = true;
}
//shortest path
for(int i=0; i<n; i++)
for(int j=0; j<n; j++)
for(int k=0; k<n; k++)
check[j][k] = check[j][k] || (check[j][i] && check[i][k]);
bool flag[205];
int res = 0;
int counter = n;
memset(flag, true, sizeof(flag));
while(counter > 0){
queue<int> q;
for(int i=0; i<n; i++){
if(flag[i] == true){
q.push(i);
counter--;
flag[i] = false;
break;
}
}//end for loop
while(q.empty() == false){
int tmp = q.front();
q.pop();
for(int i=0; i<n; i++){
if(flag[i]==true
&& check[i][tmp]==true
&& check[tmp][i]==true){
flag[i] = false;
counter--;
q.push(i);
}
}
}//end while loop
res++;
}
cout<<res<<endl;
return 0;
}
【2】Vijos P1023 Victoria的舞会3
参考了http://hi.baidu.com/ilikewzt/item/58ae7a6129b2ed36ac3e8397，写的也挺好：“找入度为0的点广搜。然后判断是否有没有被搜到的点，若有，则说明它在一个独立的环中，故在环里面随便找一个点搜即可搜遍整个环，于是对当前节点广搜。最后统计搜索的总次数。”
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <string.h>
using namespace std;
int main(){
int n, res;
vector<int> edge[205];
bool check[205];
//in degree for every vertex
int degree[205];
memset(degree, 0, sizeof(degree));
memset(check, false, sizeof(check));
cin>>n;
for(int i=0; i<n; i++){
int tmp;
while(cin>>tmp && tmp){
edge[i].push_back(tmp-1);
degree[tmp-1]++;
}
}
res = 0;
for(int i=0; i<n; i++){
//in degree is 0
if(degree[i] == 0){
queue<int> q;
q.push(i);
check[i] = true;
while(q.empty() == false){
int tmp = q.front();
q.pop();
int len = edge[tmp].size();
for(int j=0; j<len; j++){
if(check[edge[tmp][j]] == false){
q.push(edge[tmp][j]);
check[edge[tmp][j]] = true;
}
}//end for loop
}//end while loop
res++;
}//end if
}
//check for cycles
for(int i=0; i<n; i++){
if(check[i] == false){
queue<int> q;
q.push(i);
check[i] = true;
while(q.empty() == false){
int tmp = q.front();
q.pop();
int len = edge[tmp].size();
for(int j=0; j<len; j++){
if(check[edge[tmp][j]] == false){
q.push(edge[tmp][j]);
check[edge[tmp][j]] = true;
}
}//end for loop
}//end while loop
res++;
}
}
cout<<res<<endl;
//system("pause");
return 0;
}
【3】codeforces division2 D good sequence
我按照最长上升子序列的dp来写，复杂度是O(n*n)，不出所料地超时了……
关键的地方有两个：一是要按照因子来进行dp，毕竟因子一般数目要少于该整数的一半；二是如何寻找因子的问题，O(n)的复杂度是绝对接受不了的，借鉴筛法选素数的方法，可以在只算到其平方根的位置。
题目的代码虽短，还是学到了一些东西，发现基本的数论自己还是欠缺很多。
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
using namespace std;
int main(){
int n;
int res = -1;
int divisor[100005], dp[100005];
memset(divisor, 0, sizeof(divisor));
memset(dp, 0, sizeof(dp));
scanf("%d", &n);
for(int i=0; i<n; i++){
int number;
scanf("%d", &number);
if(number == 1){
dp[i] = 1;
res = max(res, dp[i]);
continue;
}
for(int j=1; j*j<=number; j++){
if(number%j == 0){
dp[i] = max(divisor[j], divisor[number/j]) + 1;
}
}
for(int j=1; j*j<=number; j++){
if(number%j == 0){
if(j > 1)
divisor[j] = max(divisor[j], dp[i]);
if(number/j > 1)
divisor[number/j] = max(divisor[number/j], dp[i]);
}
}
res = max(res, dp[i]);
}
printf("%d\n", res);
return 0;
}
【4】TCO round 1A level2
level2：首先需要想到最小值必定是在某个右边界取到的，这一点可以从动态的分析中获得。假象有一条符合要求的路径，不断缩小步距直到接触某一条线段的右边界，此时得到的是一个局部极小值。最后fail system test的根源在于精度方面考虑不够好，应当尽量避免做太多次的除法，累积误差让这题功亏一篑，在第100多组从测试数据上挂了。事后减少了除法的次数，就pass system test了，无语。。。
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <string.h>
using namespace std;
class TheFrog {
public:
double getMinimum(int, vector <int>, vector <int>);
};
double TheFrog::getMinimum(int D, vector <int> L, vector <int> R) {
//bool check[30005];
//memset(check, false, sizeof(check));
int len = L.size();
int inter = -1;
for(int i=0; i<len; i++){
inter = max(inter, R[i]-L[i]);
// for(int j=L[i]+1; j<R[i]; j++)
// check[j] = true;
}
double res = D;
for(int i=0; i<len; i++){
int div = R[i]/inter;
double cur = (double)R[i]/div;
if(cur >= res)
continue;
for(int j=div; j>=1; j--){
//cur = (double)R[i]/j;
if(R[i] >= res*j)
break;
bool fit = true;
//check code
for(int k=0; k<len; k++){
int left = (int)((L[k]*j)/R[i]);
int right = (int)((R[k]*j)/R[i]);
if((R[k]*j)%R[i] == 0
&& (R[i] >= (R[k]-L[k])*j))
continue;
// if(((R[k]-(right*cur)) < 1e-9)
// && (cur >= (R[k]-L[k])))
// continue;
if(right > left){
fit = false;
break;
}
}
if(fit == true)
res = min(res, (double)R[i]/j);
}
}
return res;
}
//Powered by [KawigiEdit] 2.0!
【5】TCO round 1A level3
楼教主7分钟就过了。。。我知道转化为一个所有顶点入度和出度均为1的图就满足要求了，没有想到二分图匹配，一时半会更敲不出最大流-最小费用算法，看ACRush的代码表示无力啊。。。
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
using namespace std;
#define SIZE(X) ((int)(X.size()))
#define LENGTH(X) ((int)(X.length()))
const int maxn=100000+5;
const int maxm=100000+5;
const int oo=1000000000;
int node,nedge,src,dest;
int head[maxn],point[maxm],next[maxm],flow[maxm],capa[maxm],cost[maxm];
int dist[maxn],expand[maxn],prev[maxn],edge[maxn];
bool changed[maxn];
void init(int _node,int _src,int _dest)
{
node=_node;
src=_src;
dest=_dest;
nedge=0;
for (int i=0;i<node;i++) head[i]=-1;
}
void addedge(int u,int v,int c,int w)
{
point[nedge]=v,capa[nedge]=c,cost[nedge]=+w,flow[nedge]=0,next[nedge]=head[u],head[u]=(nedge++);
point[nedge]=u,capa[nedge]=0,cost[nedge]=-w,flow[nedge]=0,next[nedge]=head[v],head[v]=(nedge++);
}
void ford(int &mflow,int &mcost)
{
mflow=mcost=0;
while (1)
{
for (int i=0;i<node;i++) dist[i]=oo,prev[i]=-1,changed[i]=false;
dist[src]=0;
changed[src]=true;
expand[src]=oo;
while (1)
{
bool ok=true;
for (int i=0;i<node;i++) if (changed[i])
{
changed[i]=false;
for (int k=head[i];k>=0;k=next[k])
if (flow[k]<capa[k] && dist[i]+cost[k]<dist[point[k]])
{
dist[point[k]]=dist[i]+cost[k];
changed[point[k]]=true;
prev[point[k]]=i;
edge[point[k]]=k;
expand[point[k]]=min(expand[i],capa[k]-flow[k]);
ok=false;
}
}
if (ok) break;
}
if (prev[dest]<0) break;
int d=expand[dest];
mflow+=d;
mcost+=d*dist[dest];
for (int k=dest;k!=src;k=prev[k])
{
flow[edge[k]]+=d;
flow[edge[k]^1]-=d;
}
}
}
class DirectionBoard
{
public:
int getMinimum(vector <string> a)
{
int n=SIZE(a);
int m=LENGTH(a[0]);
int size=n*m;
init(size*2+2,size*2,size*2+1);
for (int i=0;i<n*m;i++)
{
addedge(src,i,1,0);
addedge(i+size,dest,1,0);
}
int dx[]={-1,1,0,0};
int dy[]={0,0,-1,1};
char dc[]={'U','D','L','R'};
for (int x=0;x<n;x++) for (int y=0;y<m;y++) for (int d=0;d<4;d++)
{
int x2=(x+dx[d]+n)%n;
int y2=(y+dy[d]+m)%m;
addedge(x*m+y,x2*m+y2+size,1,((dc[d]==a[x][y])?0:1));
}
int c1,c2;
ford(c1,c2);
return c2;
}
};
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
