【Codeforces Round #403】Codeforces 781D Axel and Marston in Bitland

A couple of friends, Axel and Marston are travelling across the
country of Bitland. There are n towns in Bitland, with some pairs of
towns connected by one-directional roads. Each road in Bitland is
either a pedestrian road or a bike road. There can be multiple roads
between any pair of towns, and may even be a road from a town to
itself. However, no pair of roads shares the starting and the
destination towns along with their types simultaneously.

The friends are now located in the town 1 and are planning the travel
route. Axel enjoys walking, while Marston prefers biking. In order to
choose a route diverse and equally interesting for both friends, they
have agreed upon the following procedure for choosing the road types
during the travel:

The route starts with a pedestrian route.
Suppose that a beginning of the route is written in a string s of letters P (pedestrain road) and B (biking road). Then, the string is

appended to s, where stands for the string s with each character
changed to opposite (that is, all pedestrian roads changed to bike
roads, and vice versa).

In the first few steps the route will look as follows: P, PB, PBBP,
PBBPBPPB, PBBPBPPBBPPBPBBP, and so on.

After that the friends start travelling from the town 1 via Bitlandian
roads, choosing the next road according to the next character of their
route type each time. If it is impossible to choose the next road, the
friends terminate their travel and fly home instead.

Help the friends to find the longest possible route that can be
travelled along roads of Bitland according to the road types choosing
procedure described above. If there is such a route with more than
1018 roads in it, print -1 instead. Input

The first line contains two integers n and m (1 ≤ n ≤ 500,
0 ≤ m ≤ 2n2) — the number of towns and roads in Bitland respectively.

Next m lines describe the roads. i-th of these lines contains three
integers vi, ui and ti (1 ≤ vi, ui ≤ n, 0 ≤ ti ≤ 1), where vi and ui
denote start and destination towns indices of the i-th road, and ti
decribes the type of i-th road (0 for a pedestrian road, 1 for a bike
road). It is guaranteed that for each pair of distinct indices i, j
such that 1 ≤ i, j ≤ m, either vi ≠ vj, or ui ≠ uj, or ti ≠ tj holds.
Output

If it is possible to find a route with length strictly greater than
1018, print -1. Otherwise, print the maximum length of a suitable
path.

可以发现这样的规律：如果是从头开始，或者之前只走了超过$2^k$的若干$2$的整数次幂的和，那么这一步走了$2^k$步之后下一步和开始一定是相反的。
这样就可以倍增了，$dp[i][k][x]$表示从$i$出发，走$2^k$步，第一步走$x$（$0$或$1$）能到达哪些点，放在一个bitset里。
因为转移是$O\left( \cfrac{n^2}w\right)$的，复杂度是$O\left(\cfrac{n^3 \log 10^{18}}{w}\right)$。

#include<cstdio>
#include<cstring>
#include<bitset>
#include<algorithm>
using namespace std;
#define LL long long
bitset<510> f[510][65][2],now,tem;
int n,m;
int main()
{
    int u,v,x,cur;
    LL ans=0;
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&u,&v,&x);
        u--;
        v--;
        f[u][0][x][v]=1;
    }
    for (int k=1;k<=60;k++)
        for (int i=0;i<n;i++)
            for (int p=0;p<2;p++)
                for (int j=0;j<n;j++)
                    if (f[i][k-1][p][j])
                        f[i][k][p]|=f[j][k-1][p^1];
    now[0]=1;
    cur=0;
    for (int k=60;k>=0;k--)
    {
        tem.reset();
        for (int i=0;i<n;i++)
            if (now[i]) tem|=f[i][k][cur];
        if (tem.count())
        {
            ans+=1LL<<k;
            now=tem;
            cur^=1;
        }
    }
    if (ans>1e18) printf("-1\n");
    else printf("%I64d\n",ans);
}