20201114考试

又考崩了

今天迟到了，然后考试前一个小时都想睡觉....

T1 请问您今天要来点数对吗？

好像还是比较简单的，直接用二进制即可

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int MAXN = 2e7 + 3;
int n;
ll ans;
int ma[1<<11];
int main(){
    freopen( "number.in" , "r" , stdin );
    freopen( "number.out" , "w" , stdout );
    scanf( "%d" , &n );
    for( int i = 1 ; i <= n ; i ++ ){
        int m = i , sum = 0;
        while( m ){
            int p = m % 10;
            sum |= ( 1 << ( p ) );
            m /= 10;
        }
        ans += ma[sum];
       // printf( "%d %d\n" , i , sum );
        ma[sum] ++;
    }
    printf( "%lld\n" , ans );
}

T2：请问您今天要来点兔子吗？

这道题也比较简单，发现其实fib[60]已经大于1e12了，所以直接暴力找到自己的父亲，一个个比较即可

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int MAXN = 3e5 + 3;
const int MAXV = 1e5 + 3;
int n , m ;
ll fib[65], fa1[63] , fa2[63];
inline char GetChar(){
    static char buf[10001],*p1=buf,*p2=buf;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,10001,stdin),p1==p2)?EOF:*p1++;
}
inline void Read(ll &n){
    short f=1;
    long long x=0;
    char c=GetChar();
    while(isdigit(c)==false){
        if(c=='-'){
            f=-1;
		}
        c=GetChar();
    }
    while(isdigit(c)==true){
    	x=((x<<3)+(x<<1)+(c^48));
        c=GetChar();
    }
    n=x*f;
}
inline void write(ll x){
	if (x < 0) x = ~x + 1, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
int main(){
	freopen( "fibonacci_rabbit.in" , "r" , stdin );
	freopen( "fibonacci_rabbit.out" , "w" , stdout );
    scanf( "%d" , &m );
    fib[1] = fib[2] = 1;
    for( int i = 3 ; i <= 61 ; i ++ ){
        fib[i] = fib[i-1] + fib[i-2];
    }
    while( m -- ){
        ll x , y;Read( x );Read( y );
        int ncnt1 =0  , ncnt2 = 0;
        for( int i = 1 ; i <= 61 ; i ++ ) fa1[i] = fa2[i] = 0;
        fa1[++ncnt1] = x;
        while( x != 1 ){
            int len = lower_bound( fib + 1 , fib + 61 + 1 , x ) - fib;
            len --;
            fa1[++ncnt1] = x - fib[len];
            x -= fib[len];
        }
        fa2[++ncnt2] = y;
        while( y != 1 ){
            int len = lower_bound( fib + 1 , fib + 61 + 1 , y ) - fib;
            len --;
            fa2[++ncnt2] = y - fib[len];
            y-= fib[len];
        }
        bool flag = 0;int i , j;
        for( i = ncnt1 , j = ncnt2 ; i >= 1 && j >= 1 ; i -- , j -- ){
            if( fa1[i] != fa2[j] ){
                write( fa1[i+1] );
                putchar( '\n' );
                flag = 1;break;
            }
        }
        if( !flag ){
            if( !i ){
            	write( fa1[1] );
                putchar( '\n' );
			}
            else{
            	write( fa2[1] );
                putchar( '\n' );
			}
        }
    }
}

T3 请问您今天要来点量子波动吗？

首先可以有一个很简单的O(n^2logn)的dp，然后考虑优化

我自己的dp是设的当前点是奇数点所得到的最大长度，于是还要维护以某个点为结尾作为偶点的最大长度

那么两个东西可以用树状数组维护，直接搞即可

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int MAXN = 3e5 + 3;
int dp[MAXN] , tre[MAXN] , n , K , maxx[MAXN];
struct node{
    int num , x;
    node(){}
    node( int N , int X ){
        num = N , x  = X;
    }
    friend bool operator < ( node a , node b ){
        return a.x < b.x;
    }
}a[MAXN];
bool cmp( node a , node b ){
    return a.num < b.num;
}
int s[MAXN] , ncnt;
void modify( int x , int delta ){
    for( ; x <= ncnt ; x += ( x & -x ) ) tre[x] = max( tre[x] , delta );
}
int query( int x ){
    int sum = 0;
    for( ; x ; x -= ( x & -x ) ) sum = max( sum , tre[x] );
    return sum;
}
int tre1[MAXN];
void modify1( int x , int delta ){
    for( ; x <= ncnt ; x += ( x & -x ) ) tre1[x] = max( tre1[x] , delta );
}
int query1( int x ){
    int sum = 0;
    for( ; x ; x -= ( x & -x ) ) sum = max( sum , tre1[x] );
    return sum;
}
int main(){
	//freopen( "wave.in" , "r" , stdin );
	//freopen( "wave.out" , "w" , stdout );
    scanf( "%d%d" , &n , &K );
    for( int i = 1 ; i <= n ; i ++ ){
        scanf( "%d" , &a[i].x );a[i].num = i;
    }
    sort( a + 1 , a + n + 1 );
    ncnt =0;
    for( int i = 1 ; i <= n ; i ++ ){
        if( a[i].x != a[i-1].x || i == 1 )
            s[a[i].num] = ++ncnt;
        else
            s[a[i].num] = ncnt;
    }
    sort( a + 1 , a + n + 1 , cmp );
    set<node>se;
    dp[1] = 1;
    int ans = 1;
    se.insert( a[1] );
    for( int i = 2 ; i <= n ; i ++ ){
        set<node>::iterator it = se.lower_bound( node( 0 , a[i].x + K ) );
        if( it != se.end() ){
            dp[i] = query1( ncnt - s[(*it).num] + 1 ) + 1;
            ans = max( ans , dp[i] + dp[i] - 1 );
        }
        modify( s[a[i-1].num] , dp[i-1] );
        set<node>::iterator it1 = se.upper_bound( node( 0 , a[i].x - K ) );
        if( it1 != se.begin() ){
            it1 --;
            maxx[i] = query( s[(*it1).num] );
            printf( "%d %d\n" , i , maxx[i] );
            ans = max( maxx[i] + maxx[i] , ans );
            modify1( ncnt - s[a[i].num] + 1 , maxx[i] );
        }
        se.insert( a[i] );
    }
    printf( "%d\n" , ans );
    return 0;
}

T4 请问您今天要来点图论吗？

这道题贪心显然是正确的，那么就考虑对于l，一直加边到r使1，n联通，那么一个块就是（l，r-1）

现在考虑怎样判断是否联通

考虑延时访问，那么就是当起点可以被1走到的时候才去更新所有从u走到的点

这样每一条边最多被访问一次，用链式存图

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int MAXN = 5e5 + 3;
int n , m , fa[MAXN];
struct node{
    int to , nex;
}G[MAXN<<1];
int head[MAXN] , cnt = 1;
int vis[MAXN] , ans = 1;
void dfs( int x ){
    for( int i = head[x] ; i ; i = G[i].nex ){
        int v = G[i].to;
        if( vis[v] == ans ) continue;
        vis[v] = ans;
        dfs( v );
    }
}
int U[MAXN] , V[MAXN];
int main(){
    scanf( "%d%d" , &n , &m );vis[1] = ans;
    int last = 0;
    for( int i = 1 ; i <= m ; i ++ ){
        int u ,v;scanf( "%d%d" , &u , &v );
        G[cnt].nex = head[u] , G[cnt].to = v , head[u] = cnt ++;
        if( vis[u] == ans ){
            dfs( u );
        }U[i] = u , V[i] = v;
        if( vis[n] == ans ){
            ans ++;vis[1] = ans;
            int j = i;
            while( j >= last ){
                head[U[j]] = 0;j --;
            }
            last = i;
            G[cnt].nex = head[u] , G[cnt].to = v , head[u] = cnt ++;
            if( u == 1 ) vis[v] = ans;
        }
    }
    printf( "%d\n" , ans );
    return 0;
}

自己最开始想的是并查集，其实这里是不可以的

并查集要保证当前的连通块中任意两个节点都满足需要维护的性质，且加入一个点后这个点必须与块内所有点都满足次条件

显然当一号点加入的时候有可能不是这其中所有点都可以到1

所以只能用DFS