Solution -「OurOJ 46544」漏斗计算

$\mathcal{Description}$

  Link.

  定义一个运算结点 $u$ 有两个属性：当前容量 $x_u$、最大容量 $V_u$。提供以下单元操作：

1. I 读入一个整数 $x$，令新结点 $u=(x,x)$。

2. F u 装满 $u$ 结点，即令 $x_u=V_u$。

3. E u 清空 $u$ 结点，即令 $x_u=0$。

4. C s 令新结点 $u=(0,s)$。

5. M u 令新结点 $v=(0,x_u)$。

6. T u v 不断令 $x_u\leftarrow x_u-1,x_v\leftarrow x_v-1$ 直到 $x_u=0$ 或 $x_v=V_v$。

  构造不超过 $10^4$ 次操作的一个运算方法，输入 $a,b$，输出 $ab\bmod 2^{18}$。

  $0\le a,b\le 10^5$。

$\mathcal{Solution}$

  貌似是瓶子国的某个点？反正很离谱就是了。

  首先观察操作，我们只有一个二元运算 $T(u,v)$，必然只能用它实现逻辑模块。

  再从问题入手，不难想到可以龟速乘计算 $ab$，过程中若值 $\ge 2^{18}$，则减去 $2^{18}$。那么我们至少需要实现这些模块：

• 加法器：输入结点 $u,v$，输出 $w$，满足 $x_w=x_u+x_v$。

• 逻辑减法器：输入结点 $u,v$，输出 $w$，若 $x_u\ge x_v$，$x_w=x_u-x_v$；否则 $x_w=x_u$。

  加法器比较方便：新建一个大容量点，把两个加数复制一份倒进去就好。先实现一个复制当前容量器：

inline int copyNum( const int u ) {
    printf( "M %d\n", u ), ++node;
    printf( "F %d\n", node );
    return node;
}

  再实现加法器：

inline int add( const int u, const int v ) {
    printf( "C 1000000000\n" ); int res = ++node;
    printf( "T %d %d\n", copyNum( u ), res );
    printf( "T %d %d\n", copyNum( v ), res );
    return res;
}

  逻辑减法？先要判断大小关系。而 $T(u,v)$ 之后 $x'_u=\max\{x_u-x_v,0\}$，我们只需要判断一个结点的当前容量是否为 $0$。好消息是，我们能够实现逻辑非器：

inline int logicNot( const int u ) {
    printf( "M %d\n", u ), ++node;
    puts( "C 1" ), ++node;
    printf( "F %d\n", node );
    printf( "T %d %d\n", node, node - 1 );
    return node;
}

  内部逻辑比较易懂就不讲啦。在此基础上，实现普通减法器和逻辑减法器：

inline int sub( const int u, const int v ) {
    printf( "M %d\n", v ); int tmp = ++node;
    printf( "T %d %d\n", copyNum( u ), tmp );
    return node;
}

inline PII logicSub( int u, int v ) {
    int f = logicNot( sub( u = add( u, 1 ), v ) );
    rep ( i, 1, 18 ) f = add( f, f );
    printf( "M %d\n", f ), f = ++node;
    printf( "T %d %d\n", v = copyNum( v ), f );
    return { u = sub( sub( u, v ), 1 ), f };
}

  逻辑减法器返回的 first 即减法结果，second 用于求解时重复利用。

  底层方法实现之后，剩下的工作就简单了：输入 $a,b$，计算 $2a,4a,\cdots,2^{16}a$，枚举 $b$ 是否大于等于 $2^{16}\dots2^0$，若是，则减去，答案加上对应的权。都能用以逻辑非为基础的模块实现。

  操作次数复杂度为 $\mathcal O(\log^2 V)$（倍增以及内部的逻辑减法），我实现的常数较大，不过封装成模块很易懂就是了。（

$\mathcal{Code}$

/*+Rainybunny+*/

#include <bits/stdc++.h>

#define rep( i, l, r ) for ( int i = l, rep##i = r; i <= rep##i; ++i )
#define per( i, r, l ) for ( int i = r, per##i = l; i >= per##i; --i )

typedef std::pair<int, int> PII;
#define fi first
#define se second

int node, mod;

namespace StandardModuleLibrary {

inline int logicNot( const int u ) {
    printf( "M %d\n", u ), ++node;
    puts( "C 1" ), ++node;
    printf( "F %d\n", node );
    printf( "T %d %d\n", node, node - 1 );
    return node;
}

inline int copyNum( const int u ) {
    printf( "M %d\n", u ), ++node;
    printf( "F %d\n", node );
    return node;
}

inline int add( const int u, const int v ) {
    printf( "C 1000000000\n" ); int res = ++node;
    printf( "T %d %d\n", copyNum( u ), res );
    printf( "T %d %d\n", copyNum( v ), res );
    return res;
}

inline int sub( const int u, const int v ) {
    printf( "M %d\n", v ); int tmp = ++node;
    printf( "T %d %d\n", copyNum( u ), tmp );
    return node;
}

inline PII logicSub( int u, int v ) {
    int f = logicNot( sub( u = add( u, 1 ), v ) );
    rep ( i, 1, 18 ) f = add( f, f );
    printf( "M %d\n", f ), f = ++node;
    printf( "T %d %d\n", v = copyNum( v ), f );
    return { u = sub( sub( u, v ), 1 ), f };
}

} using namespace StandardModuleLibrary;

int main() {
    freopen( "liver.out", "w", stdout );

    int x, y;
    printf( "C 1\nF 1\n" ), node = 1; // element 1.
    printf( "C 262144\nF 2\n" ), mod = node = 2; // module.
    puts( "I" ), x = ++node;
    puts( "I" ), y = ++node;

    int buc[30] = { x }, pwr[30] = {};
    int ans = ++node; puts( "C 1000000000" );

    pwr[0] = ++node, printf( "C 1\nF %d\n", node );
    rep ( i, 1, 16 ) {
        pwr[i] = ++node, printf( "C %d\nF %d\n", 1 << i, node );
        PII shit( logicSub( add( buc[i - 1], buc[i - 1] ), mod ) );
        buc[i] = shit.fi;
    }

    per ( i, 16, 0 ) {
        PII r( logicSub( y, pwr[i] ) );
        int x = r.se;
        rep ( j, 1, 18 - i ) x = add( x, x );
        printf( "M %d\n", x ), x = ++node;
        printf( "T %d %d\n", buc[i], x ), y = r.fi;
        ans = logicSub( add( ans, buc[i] ), mod ).fi;
    }

    printf( "P %d\n", ans );
    return 0;
}