oj.uz

Submission #471743

# Submission time Handle Problem Language Result Execution time Memory
471743 2021-09-10T16:03:11 Z NhatMinh0208 Art Class (IOI13_artclass) C++14
89 / 100
 99 ms 16124 KB 
#ifndef CPL_TEMPLATE
#define CPL_TEMPLATE
/*
	Normie's Template v2.5
	Changes:
    Added warning against using pragmas on USACO.
*/
// Standard library in one include.
#include <bits/stdc++.h>
using namespace std;
 
// ordered_set library.
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set(el) tree<el,null_type,less<el>,rb_tree_tag,tree_order_statistics_node_update>
 
// AtCoder library. (Comment out these two lines if you're not submitting in AtCoder.) (Or if you want to use it in other judges, run expander.py first.)
//#include <atcoder/all>
//using namespace atcoder;

//Pragmas (Comment out these three lines if you're submitting in szkopul or USACO.)
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast,unroll-loops,tree-vectorize")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
 
//File I/O.
#define FILE_IN "cseq.inp"
#define FILE_OUT "cseq.out"
#define ofile freopen(FILE_IN,"r",stdin);freopen(FILE_OUT,"w",stdout)
 
//Fast I/O.
#define fio ios::sync_with_stdio(0);cin.tie(0)
#define nfio cin.tie(0)
#define endl "\n"
 
//Order checking.
#define ord(a,b,c) ((a>=b)and(b>=c))
 
//min/max redefines, so i dont have to resolve annoying compile errors.
#define min(a,b) (((a)<(b))?(a):(b))
#define max(a,b) (((a)>(b))?(a):(b))

// Fast min/max assigns to use with AVX.
// Requires g++ 9.2.0.
template<typename T>
__attribute__((always_inline)) void chkmin(T& a, const T& b) {
    a=(a<b)?a:b;
}

template<typename T>
__attribute__((always_inline)) void chkmax(T& a, const T& b) {
    a=(a>b)?a:b;
}
 
//Constants.
#define MOD (ll(998244353))
#define MAX 300001
#define mag 320
const long double PI=3.14159265358979;
 
//Pairs and 3-pairs.
#define p1 first
#define p2 second.first
#define p3 second.second
#define fi first
#define se second
#define pii(element_type) pair<element_type,element_type>
#define piii(element_type) pair<element_type,pii(element_type)>
 
//Quick power of 2.
#define pow2(x) (ll(1)<<x)
 
//Short for-loops.
#define ff(i,__,___) for(int i=__;i<=___;i++)
#define rr(i,__,___) for(int i=__;i>=___;i--)
 
//Typedefs.
#define bi BigInt
typedef long long ll;
typedef long double ld;
typedef short sh;

// Binpow and stuff
ll BOW(ll a, ll x, ll p)
{
	if (!x) return 1;
	ll res=BOW(a,x/2,p);
	res*=res;
	res%=p;
	if (x%2) res*=a;
	return res%p;
}
ll INV(ll a, ll p)
{
	return BOW(a,p-2,p);
}
//---------END-------//
#endif
#include "artclass.h"


const int DIFF_LIM = 20;
const ld CC_LIM = 0.005;
vector<int> vec;
int n,m,i,j,k,t,t1,u,v,a;
int used[500][500],r[500][500],g[500][500],b[500][500];
void dfs(int i, int j){
    used[i][j]=1;
    a++;
    int _i, _j;
    _i=i+1;
    _j=j+1;
    if (_i>=0 && _i<n && _j>=0 && _j<m && !used[_i][_j] && abs(r[i][j]-r[_i][_j])+abs(g[i][j]-g[_i][_j])+abs(b[i][j]-b[_i][_j])<=DIFF_LIM) {
        dfs(_i, _j);
    }
    _i=i-1;
    _j=j+1;
    if (_i>=0 && _i<n && _j>=0 && _j<m && !used[_i][_j] && abs(r[i][j]-r[_i][_j])+abs(g[i][j]-g[_i][_j])+abs(b[i][j]-b[_i][_j])<=DIFF_LIM) {
        dfs(_i, _j);
    }
    _i=i+1;
    _j=j-1;
    if (_i>=0 && _i<n && _j>=0 && _j<m && !used[_i][_j] && abs(r[i][j]-r[_i][_j])+abs(g[i][j]-g[_i][_j])+abs(b[i][j]-b[_i][_j])<=DIFF_LIM) {
        dfs(_i, _j);
    }
    _i=i-1;
    _j=j-1;
    if (_i>=0 && _i<n && _j>=0 && _j<m && !used[_i][_j] && abs(r[i][j]-r[_i][_j])+abs(g[i][j]-g[_i][_j])+abs(b[i][j]-b[_i][_j])<=DIFF_LIM) {
        dfs(_i, _j);
    }
}
int style( int H,int W,
        int R[500][500],int G[500][500],int B[500][500]) {
    for (i=0;i<H;i++) for (j=0;j<W;j++) {
        used[i][j]=0;
        r[i][j]=R[i][j];
        g[i][j]=G[i][j];
        b[i][j]=B[i][j];
    }
    n=H;
    m=W;
    
    for (i=0;i<n;i++) for (j=0;j<m;j++) if (!used[i][j]) {
        a=0;
        dfs(i,j);       
        if ((ld)a/(n*m)>=CC_LIM) vec.push_back(a);
    }
    
    sort(vec.begin(),vec.end());
    int aa=vec.size();
    ld bb=((vec.size())?((ld)vec[vec.size()-1]/(n*m)):(0));
    // cout<<vec.size()<<" "<<((vec.size())?((ld)vec[vec.size()-1]/(n*m)):(0))<<endl;
    if (bb<=0.01) return 3; 
    if (bb>=0.2 && aa<=10) return 4;
    if (aa>=15 || bb>=0.2) return 1;
    return 2;
}
// Normie28;

Compilation message

artclass.cpp:23: warning: ignoring '#pragma comment ' [-Wunknown-pragmas]
   23 | #pragma comment(linker, "/stack:200000000")
      |

Subtask #1
89.0 / 100.0

# Verdict Execution time Memory Grader output
1 Correct 65 ms 8164 KB Output is correct
2 Correct 53 ms 11844 KB Output is correct
3 Correct 63 ms 6880 KB Output is correct
4 Correct 58 ms 8488 KB Output is correct
5 Incorrect 58 ms 8516 KB Output isn't correct
6 Correct 38 ms 4876 KB Output is correct
7 Correct 35 ms 4284 KB Output is correct
8 Correct 99 ms 7436 KB Output is correct
9 Correct 55 ms 7084 KB Output is correct
10 Correct 74 ms 9132 KB Output is correct
11 Correct 64 ms 8504 KB Output is correct
12 Correct 57 ms 6708 KB Output is correct
13 Correct 66 ms 9068 KB Output is correct
14 Correct 72 ms 10184 KB Output is correct
15 Correct 45 ms 8428 KB Output is correct
16 Correct 51 ms 11340 KB Output is correct
17 Correct 63 ms 7828 KB Output is correct
18 Correct 57 ms 6920 KB Output is correct
19 Correct 66 ms 12708 KB Output is correct
20 Incorrect 49 ms 4516 KB Output isn't correct
21 Correct 45 ms 11588 KB Output is correct
22 Correct 95 ms 7176 KB Output is correct
23 Correct 69 ms 8048 KB Output is correct
24 Correct 65 ms 8400 KB Output is correct
25 Correct 68 ms 9164 KB Output is correct
26 Correct 72 ms 14320 KB Output is correct
27 Correct 66 ms 11716 KB Output is correct
28 Correct 49 ms 8132 KB Output is correct
29 Correct 47 ms 5724 KB Output is correct
30 Correct 62 ms 11280 KB Output is correct
31 Incorrect 58 ms 5572 KB Output isn't correct
32 Correct 76 ms 15432 KB Output is correct
33 Correct 52 ms 8136 KB Output is correct
34 Correct 60 ms 7956 KB Output is correct
35 Correct 56 ms 6464 KB Output is correct
36 Correct 67 ms 7292 KB Output is correct
37 Correct 65 ms 6724 KB Output is correct
38 Correct 48 ms 10648 KB Output is correct
39 Correct 53 ms 13116 KB Output is correct
40 Correct 76 ms 11732 KB Output is correct
41 Correct 35 ms 3976 KB Output is correct
42 Correct 73 ms 10212 KB Output is correct
43 Correct 70 ms 8752 KB Output is correct
44 Correct 60 ms 8588 KB Output is correct
45 Correct 58 ms 9048 KB Output is correct
46 Correct 88 ms 9672 KB Output is correct
47 Correct 56 ms 6824 KB Output is correct
48 Correct 47 ms 5824 KB Output is correct
49 Incorrect 81 ms 9768 KB Output isn't correct
50 Correct 67 ms 16124 KB Output is correct
51 Incorrect 63 ms 7248 KB Output isn't correct
52 Correct 61 ms 5912 KB Output is correct
53 Incorrect 53 ms 10040 KB Output isn't correct
54 Correct 17 ms 2236 KB Output is correct
55 Correct 72 ms 12384 KB Output is correct
56 Correct 85 ms 8516 KB Output is correct
57 Correct 75 ms 7636 KB Output is correct
58 Correct 57 ms 7256 KB Output is correct
59 Correct 62 ms 7000 KB Output is correct
60 Correct 61 ms 8648 KB Output is correct
61 Correct 36 ms 4036 KB Output is correct
62 Correct 61 ms 6488 KB Output is correct
63 Correct 73 ms 8912 KB Output is correct
64 Correct 41 ms 9080 KB Output is correct
65 Correct 94 ms 8400 KB Output is correct
66 Correct 66 ms 6804 KB Output is correct
67 Correct 69 ms 11740 KB Output is correct
68 Incorrect 77 ms 7940 KB Output isn't correct
69 Incorrect 74 ms 9704 KB Output isn't correct
70 Correct 60 ms 6572 KB Output is correct
71 Correct 65 ms 7168 KB Output is correct
72 Correct 75 ms 7976 KB Output is correct
73 Correct 79 ms 8280 KB Output is correct
74 Correct 62 ms 13436 KB Output is correct
75 Correct 63 ms 13844 KB Output is correct
76 Correct 62 ms 8628 KB Output is correct
77 Incorrect 54 ms 5900 KB Output isn't correct
78 Correct 21 ms 8652 KB Output is correct
79 Correct 56 ms 10312 KB Output is correct
80 Correct 38 ms 9848 KB Output is correct
81 Correct 59 ms 6520 KB Output is correct
82 Correct 45 ms 8236 KB Output is correct
83 Correct 61 ms 8024 KB Output is correct
84 Correct 65 ms 13764 KB Output is correct
85 Incorrect 62 ms 5956 KB Output isn't correct
86 Incorrect 60 ms 7624 KB Output isn't correct
87 Correct 41 ms 4900 KB Output is correct
88 Incorrect 52 ms 6136 KB Output isn't correct
89 Correct 69 ms 8584 KB Output is correct
90 Correct 63 ms 14112 KB Output is correct
91 Correct 58 ms 14100 KB Output is correct
92 Correct 65 ms 7572 KB Output is correct
93 Correct 70 ms 14968 KB Output is correct
94 Incorrect 91 ms 6340 KB Output isn't correct
95 Correct 61 ms 8248 KB Output is correct
96 Incorrect 61 ms 6292 KB Output isn't correct
97 Correct 49 ms 4980 KB Output is correct
98 Incorrect 60 ms 6468 KB Output isn't correct
99 Correct 40 ms 5224 KB Output is correct
100 Correct 55 ms 8324 KB Output is correct
101 Correct 49 ms 12868 KB Output is correct
102 Correct 74 ms 9920 KB Output is correct