Submission #854725

# Submission time Handle Problem Language Result Execution time Memory
854725 2023-09-28T16:13:19 Z Tenis0206 Squirrel (RMI18_squirrel) C++11
50 / 100
4700 ms 114732 KB
#include <bits/stdc++.h>

using namespace std;

const int vmax = 5e4;

int dx[] = {-1,0,1,0};
int dy[] = {0,1,0,-1};

int m,n,f;

vector<pair<int,int>> l;
vector<pair<pair<int,int>,int>> t[15];

int nrfact[vmax + 5], coef[vmax + 5];
bool bad[vmax + 5];

vector<int> d[vmax + 5];

void solve(int x, int y, int s, int dir)
{
    for(int i=1; i<=s; i++)
    {
        int xx = x + i * dx[dir];
        int yy = y + i * dy[dir];
        l.push_back({xx,yy});
    }
    x = x + s * dx[dir];
    y = y + s * dy[dir];
    if(s==1)
    {
        return;
    }
    for(int i=1; i<=s/2; i++)
    {
        int xs = x + i * dx[dir] + i * dx[(dir + 3) % 4];
        int ys = y + i * dy[dir] + i * dy[(dir + 3) % 4];
        l.push_back({xs,ys});
    }
    solve(x + (s / 2) * dx[dir] + (s / 2) * dx[(dir + 3) % 4], y + (s / 2) * dy[dir] + (s / 2) * dy[(dir + 3) % 4], s / 2, dir);
    solve(x + (s / 2) * dx[dir] + (s / 2) * dx[(dir + 3) % 4], y + (s / 2) * dy[dir] + (s / 2) * dy[(dir + 3) % 4], s / 2, (dir + 3) % 4);
    for(int i=1; i<=s/2; i++)
    {
        int xd = x + i * dx[dir] + i * dx[(dir + 1) % 4];
        int yd = y + i * dy[dir] + i * dy[(dir + 1) % 4];
        l.push_back({xd,yd});
    }
    solve(x + (s / 2) * dx[dir] + (s / 2) * dx[(dir + 1) % 4], y + (s / 2) * dy[dir] + (s / 2) * dy[(dir + 1) % 4], s / 2, dir);
    solve(x + (s / 2) * dx[dir] + (s / 2) * dx[(dir + 1) % 4], y + (s / 2) * dy[dir] + (s / 2) * dy[(dir + 1) % 4], s / 2, (dir + 1) % 4);
}

void precalc_paths()
{
    for(int p=0; p<=10; p++)
    {
        int s = (1<<p);
        l.push_back({0,0});
        solve(0,0,s,0);
        sort(l.begin(),l.end());
        int cnt = 1;
        for(int i=1; i<l.size(); i++)
        {
            if(l[i]!=l[i-1])
            {
                t[p].push_back({l[i - 1], cnt});
                cnt = 1;
            }
            else
            {
                ++cnt;
            }
        }
        t[p].push_back({l.back(),cnt});
        l.clear();
    }
}

void precalc_factors()
{
    for(int i=2; i<=vmax; i++)
    {
        if(!nrfact[i])
        {
            for(int j=i; j<=vmax; j+=i)
            {
                ++nrfact[j];
                if((j / i) % i == 0)
                {
                    bad[j] = true;
                }
            }
        }
    }
    for(int i=1; i<=vmax; i++)
    {
        if(!bad[i])
        {
            if(nrfact[i] % 2 == 1)
            {
                coef[i] = -1;
            }
            else
            {
                coef[i] = 1;
            }
        }
    }
    for(int i=1; i<=vmax; i++)
    {
        if(coef[i])
        {
            for(int j=i; j<=vmax; j+=i)
            {
                d[j].push_back(i);
            }
        }
    }
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
#ifdef home
    freopen("nr.in","r",stdin);
    freopen("nr.out","w",stdout);
#endif // home
    cin>>m>>n>>f;
    precalc_paths();
    precalc_factors();
    int rez = 0;
    for(int i=1; i<=f; i++)
    {
        int x,y,s;
        cin>>x>>y>>s;
        int p = 0;
        while(s!=1)
        {
            ++p;
            s /= 2;
        }
        for(auto it : t[p])
        {
            if(it.first.first + x - 1 == 0)
            {
                rez += (it.first.second + y - 1 == 1) * it.second;
            }
            else if(it.first.second + y - 1 == 0)
            {
                rez += (it.first.first + x - 1 == 1) * it.second;
            }
            else
            {
                for(auto div : d[it.first.second + y - 1])
                {
                    if((it.first.first + x - 1) % div != 0)
                    {
                        continue;
                    }
                    rez += coef[div] * it.second;
                }
            }
        }
    }
    cout<<rez<<'\n';
    return 0;
}

Compilation message

squirrel.cpp: In function 'void precalc_paths()':
squirrel.cpp:61:23: warning: comparison of integer expressions of different signedness: 'int' and 'std::vector<std::pair<int, int> >::size_type' {aka 'long unsigned int'} [-Wsign-compare]
   61 |         for(int i=1; i<l.size(); i++)
      |                      ~^~~~~~~~~
# Verdict Execution time Memory Grader output
1 Correct 418 ms 112904 KB Output is correct
2 Correct 443 ms 114732 KB Output is correct
3 Correct 1685 ms 112884 KB Output is correct
# Verdict Execution time Memory Grader output
1 Correct 2458 ms 113212 KB Output is correct
2 Correct 2455 ms 112544 KB Output is correct
# Verdict Execution time Memory Grader output
1 Correct 3820 ms 113164 KB Output is correct
2 Correct 3863 ms 111892 KB Output is correct
3 Correct 4053 ms 112272 KB Output is correct
4 Correct 4109 ms 112392 KB Output is correct
5 Correct 4335 ms 112636 KB Output is correct
# Verdict Execution time Memory Grader output
1 Execution timed out 4709 ms 112128 KB Time limit exceeded
2 Execution timed out 4750 ms 113536 KB Time limit exceeded
3 Execution timed out 4763 ms 112644 KB Time limit exceeded
4 Execution timed out 4739 ms 114440 KB Time limit exceeded
5 Execution timed out 4712 ms 112984 KB Time limit exceeded
6 Execution timed out 4742 ms 113376 KB Time limit exceeded
7 Execution timed out 4720 ms 113760 KB Time limit exceeded
8 Execution timed out 4732 ms 114000 KB Time limit exceeded
9 Execution timed out 4757 ms 112896 KB Time limit exceeded
10 Execution timed out 4723 ms 112392 KB Time limit exceeded