【BZOJ-3243】向量内积随机化 + 矩阵

3243: [Noi2013]向量内积

Time Limit: 10 Sec Memory Limit: 256 MBSec Special Judge
Submit: 1249 Solved: 248
[Submit][Status][Discuss]

Description

两个d 维向量A=[a1,a2,...,ad]与B=[b1,b2,...,bd]的内积为其相对应维度的权值的乘积和，即：

现有 n 个d 维向量x1,...,xn ，小喵喵想知道是否存在两个向量的内积为k的倍数。请帮助她解决这个问题

Input

第一行包含3个正整数n,d,k，分别表示向量的个数，维数以及待检测的倍数。接下来n行每行有d个非负整数，其中第i行的第j个整数表示向量xi的第j维权值xi,j。

N<=100000,D<=30,K<=3,Xi,j<10

Output

包含两个整数，用空格隔开。如果存在两个向量xp,xq的内积为k的整数倍，则输出两个向量的编号p与q（要求p<q）。如果存在多组这样的向量组合，输出其中任意一组即可。若不存在这样的向量组合，则输出两个-1。

Sample Input

2 20 2
0 0 1 1 1 1 1 0 1 1 1 0 1 0 0 0 1 1 1 1
1 0 1 0 1 0 1 1 1 1 0 1 1 1 0 1 1 0 1 0

Sample Output

1 2

HINT

新增数据一组,但未重测By TA1111,2016.5.17

Source

Solution

这道题非常劲。

首先在这道题因为只是输出一组即可，所以，可以想到乱搞。

最暴力的方法就是$O(N^2d)$的复杂度枚举，非常不科学。

考虑利用矩阵的性质，直接用$A*A^{T}$，这样的复杂度还是$O(N^{2}d)$的。

然后我们考虑随机乱搞。直接随机两个相乘，误差太大，复杂度极不稳定。

然后我们考虑拿一个向量，去和其他所有向量相乘。这样单次的复杂度是$O(Nd)$的，可以稍多做几次。

在$K=2$的时候，我们关心的是矩阵中是否有0，然后我们取这样一个向量做的时候，如果有一个位置不一样，那么就说明有不同。

然后我们就可以直接暴力的找这个不同的位置了。

这样也是有概率出错的，所以我们需要多做几次。

至于这个向量的选取，我们考虑随机一个向量。对于这个矩阵，我们也可以随机一个排列，这样能降低错误概率。

然后就是$K=3$的情况了。这样就不是直接考虑$modK$后1,0的情况了，因为这样会出现0,1,2的情况，然后很神奇的，$1^{2}=1mod3=1,2^{2}=4mod3=1$

然后我们对他们平方，就变成了$d^{2}$维的向量了，就又转变为上述情况了，复杂度自然也变成了$O(d^{2})$。

TA爷说这是卡不掉的。

需要随机的那个向量，是必须随机，因为如果构造的话，是可以卡的，比如构造全1向量就可以被卡。

讲道理应该多random_shuffle几遍的，但是我就random_suffle了一遍就很exciting的AC了...然而跑的还是不快。

Code

#include<iostream>

#include<algorithm>

#include<cstdio>

#include<cstring>

#include<cstdlib>

#include<ctime>

using namespace std;

inline int read()

{

    int x=,f=; char ch=getchar();

    while (ch<'' || ch>'') {if (ch=='-') f=-; ch=getchar();}

    while (ch>='' && ch<='') {x=x*+ch-''; ch=getchar();}

    return x*f;

}

#define MAXN 100010

int N,d,K,A[MAXN][],B[],C[][];

int Judge(int x,int y)

{

    int re=;

    for (int i=; i<=d; i++) re+=A[x][i]*A[y][i];

    return re%K;

}

int OK(int x)

{

    int re=;

    if (K==)

        for (int i=; i<=d; i++) re^=B[i]&A[x][i],B[i]^=A[x][i];

    else

        for (int i=; i<=d; i++)

            for (int j=; j<=d; j++)

                re+=C[i][j]*A[x][i]*A[x][j],(C[i][j]+=A[x][i]*A[x][j])%=K;

    return re%K;

}

int id[MAXN];

void Solve()

{

    for (int i=; i<=N; i++) id[i]=i;

    random_shuffle(id+,id+N+);

    memset(B,,sizeof(B)); memset(C,,sizeof(C));

    for (int i=; i<=N; i++)

        if (OK(id[i])!=(i-)%K)

            for (int x,y,j=; j<=i-; j++)

                if (!Judge(id[i],id[j]))

                    x=min(id[i],id[j]),y=max(id[i],id[j]),printf("%d %d\n",x,y),exit();

}

int main()

{

    N=read(); d=read(); K=read();

    for (int i=; i<=N; i++)

        for (int j=; j<=d; j++)

            A[i][j]=read()%K;

    for (int i=; i<=; i++) Solve();

    puts("-1 -1");

    return ;

}