题意

有一个\(n*m\)的网格,每个格子有一个数,为\(1\)~\(n * m\)的排列
一个区间\((1<=l<=r<=n*m)\)是好的,当且仅当:数值在该区间内的格子,构成一棵树(有公共边的格子)
统计好区间数
\(n,m<=2000,n*m<=2*10^5\)

题解

首先先考虑什么情况形成了一棵树?
显然是 这个区间的点数 - 这个区间内互相连的边数 = 1 且 只有一个联通块

这样统计区间的问题一般都要双指针扫一下
我们可以固定左指针\(l\),然后让右指针\(r\)向右扫
显然如果\([l,r]\)之间的边构成了一个环,那么就不能让\(r\)往右移动,也就是保证所有的区间都不存在环
显然随着\(l\)的增加\(r\)不会减小

那么我们就可以对于每一个\(l\)都统计出ta所对应的最大的不存在环的连续区间能到哪里,也就是\(r\),这一步可以用\(LCT\)完成

现在我们的问题就是怎么快速的统计每一个合法的区间\([l,i](l\le i \le r)\)
我们已经可以确定这段区间是没有环的了
所以只需要统计哪些区间的 点数 - 边数 = 1 就好了(这个边数指的是在区间内的边)
这玩意儿怎么统计?
可以发现线段树上每个合法区间的节点的最小值就是1,所以可以统计线段树上的最小值的数量

代码

/*
用线段树统计最小值的个数 
就是在扩展的时候扩展到了一个点u
连边只连[l,u-1]之间的边
删除点l的时候只删除[l + 1 , r]的边 

*/
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
# define LL long long
const int M = 200005 ;
const int N = 2005 ;
const int INF = 1e9 ;
const int dx[] = {0 , 1 , 0 , -1} ;
const int dy[] = {1 , 0 , -1 , 0} ;
using namespace std ;

inline int read() {
    char c = getchar() ; int x = 0 , w = 1 ;
    while(c>'9'||c<'0') { if(c=='-') w = -1 ; c = getchar() ; }
    while(c>='0'&&c<='9') { x = x*10+c-'0' ; c = getchar() ; }
    return x*w ;
}

LL ans ;
int n , m , e , val[N][N] ; 
vector < int > eb[M] , ec[M] , vec ; 
struct Node {  int tmin , cnt ; } ;
inline Node chkmin(Node A , Node B) {
    Node c ; c.cnt = 0 ;
    c.tmin = min(A.tmin , B.tmin) ;
    if(c.tmin == A.tmin) c.cnt += A.cnt ;
    if(c.tmin == B.tmin) c.cnt += B.cnt ;
    return c ;
}
struct Link_Cut_Tree {
    # define ls (son[now][0])
    # define rs (son[now][1])
    int root , tot ;
    int fa[M] , son[M][2] , rev[M] , st[M] ;
    inline bool Nrt(int now) { return (son[fa[now]][0] == now || son[fa[now]][1] == now) ; }
    inline void Flip(int now) { swap(ls , rs) ; rev[now] ^= 1 ; }
    inline void pushdown(int now) {
        if(!rev[now]) return ;
        if(ls) Flip(ls) ; if(rs) Flip(rs) ;
        rev[now] = 0 ;
    }
    inline void rotate(int now) {
        int father = fa[now] , fafa = fa[father] , k = (son[father][1] == now) , w = son[now][k ^ 1] ;
        if(Nrt(father)) son[fafa][son[fafa][1] == father] = now ; son[now][k ^ 1] = father ; son[father][k] = w ;
        if(w) fa[w] = father ; fa[father] = now ; fa[now] = fafa ;
    }
    inline void splay(int now) {
        int top = 0 , father = now , fafa ; st[++top] = father ;
        while(Nrt(father)) father = fa[father] , st[++top] = father ;
        while(top) pushdown(st[top --]) ;
        while(Nrt(now)) {
            father = fa[now] , fafa = fa[father] ;
            if(Nrt(father)) rotate(((son[father][0] == now) ^ (son[fafa][0] == father)) ? now : father) ;
            rotate(now) ;
        }
    }
    inline void access(int now) {
        for(int ch = 0 ; now ; ch = now , now = fa[now])
            splay(now) , rs = ch ;
    }
    inline void makeroot(int now) {
        access(now) ; splay(now) ; Flip(now) ;
    }
    inline int findroot(int now) {
        access(now) ; splay(now) ;
        while(ls) pushdown(now) , now = ls ;
        return now ;
    }
    inline void Split(int x , int y) {
        makeroot(x) ; access(y) ; splay(y) ;
    }
    inline void Link(int x , int y) {
        makeroot(x) ;
        if(findroot(y) != x) fa[x] = y ;
    }
    inline void Cut(int x , int y) {
        makeroot(x) ;
        if(findroot(y) == x && !son[x][1] && fa[x] == y) fa[x] = son[y][0] = 0 ;
    }
    # undef ls
    # undef rs
} lct ;
struct Segment_Tree {
    # define ls (now << 1)
    # define rs (now << 1 | 1)
    int tmin[M << 2] , cnt[M << 2] , Tag[M << 2] ;
    inline void pushup(int now) {
        cnt[now] = 0 ;
        tmin[now] = min(tmin[ls] , tmin[rs]) ;
        if(tmin[ls] == tmin[now]) cnt[now] += cnt[ls] ;
        if(tmin[rs] == tmin[now]) cnt[now] += cnt[rs] ;
    }
    void build(int l , int r , int now) {
        tmin[now] = 0 ; cnt[now] = r - l + 1 ;
        if(l == r) return ; int mid = (l + r) >> 1 ;
        build(l , mid , ls) ; build(mid + 1 , r , rs) ;
    }
    inline void pushdown(int now) {
        if(!Tag[now]) return ;
        Tag[ls] += Tag[now] ; Tag[rs] += Tag[now] ;
        tmin[ls] += Tag[now] ; tmin[rs] += Tag[now] ;
        Tag[now] = 0 ;
    }
    void Change(int L , int R , int k , int l , int r , int now) {
        if(l >= L && r <= R) { tmin[now] += k ; Tag[now] += k ; return ; }
        pushdown(now) ; int mid = (l + r) >> 1 ;
        if(mid >= R) Change(L , R , k , l , mid , ls) ;
        else if(mid < L) Change(L , R , k , mid + 1 , r , rs) ;
        else Change(L , mid , k , l , mid , ls) , Change(mid + 1 , R , k , mid + 1 , r , rs) ;
        pushup(now) ;
    }
    Node query(int L , int R , int l , int r , int now) {
        if(l > R || r < L) return ((Node) { INF , 0 }) ;
        if(l >= L && r <= R) return ((Node) { tmin[now] , cnt[now] }) ;
        pushdown(now) ; int mid = (l + r) >> 1 ;
        if(mid >= R) return query(L , R , l , mid , ls) ;
        else if(mid < L) return query(L , R , mid + 1 , r , rs) ;
        else return chkmin(query(L , mid , l , mid , ls) , query(mid + 1 , R , mid + 1 , r , rs)) ;
    }
    # undef ls
    # undef rs
} seg ;

int main() {
    n = read() ; m = read() ; e = n * m ; 
    for(int i = 1 ; i <= n ; i ++)
        for(int j = 1 ; j <= m ; j ++)
            val[i][j] = read() ;
    for(int i = 1 ; i <= n ; i ++)
        for(int j = 1 , x , y ; j <= m ; j ++)
            for(int k = 0 ; k < 4 ; k ++) {
                x = i + dx[k] , y = j + dy[k] ;
                if(x < 1 || y < 1 || x > n || y > m) continue ;
                if(val[x][y] > val[i][j]) 
                    eb[val[i][j]].push_back(val[x][y]) ;
                else 
                    ec[val[i][j]].push_back(val[x][y]) ;
            }
// eb[i] 连的边都是大于i的边 
// ec[i] 连的边都是小于i的边     
    seg.build(1 , e , 1) ;
    int r = 0 ;
    for(int l = 1 ; l <= e ; l ++) {
        bool iscir = false ;
        for(int ri = r + 1 ; ri <= e ; ri ++) {
            vec.clear() ;
            for(int i = 0 , v ; i < ec[ri].size() ; i ++) {
                v = ec[ri][i] ; if(v < l) continue ;
                if(lct.findroot(ri) == lct.findroot(v)) {
                    iscir = true ; break ;
                }
                lct.Link(ri , v) ;
                vec.push_back(v) ;
            }
            for(int i = 0 ; i < vec.size() ; i ++) 
                lct.Cut(ri , vec[i]) ;
            if(iscir) break ;
            ++ r ; int tot = 0 ;
            for(int i = 0 , v ; i < ec[ri].size() ; i ++) {
                v = ec[ri][i] ; if(v < l) continue ;
                lct.Link(ri , v) ; ++ tot ;
            }
            seg.Change( ri , e , - tot , 1 , e , 1 ) ;
            seg.Change( ri , ri , r - l + 1 , 1 , e , 1 ) ;
        }
        Node temp = seg.query(l , r , 1 , e , 1) ;
        if(temp.tmin == 1) ans += temp.cnt ;
        for(int i = 0 , v ; i < eb[l].size() ; i ++) {
            v = eb[l][i] ; if(v > r) continue ;
            lct.Cut(l , v) ;
            seg.Change( v , e , 1 , 1 , e , 1 ) ;
        }
        seg.Change(l , r , -1 , 1 , e , 1) ;
    }
    printf("%lld\n",ans) ;
    return 0 ;
}