//#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("avx")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

#define re return
#define pb push_back
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define sqrt(x) sqrt(abs(x))
#define mp make_pair
#define pi (3.14159265358979323846264338327950288419716939937510)
#define fo(i, n) for(int i = 0; i < n; ++i)
#define ro(i, n) for(int i = n - 1; i >= 0; --i)
#define unique(v) v.resize(unique(all(v)) - v.begin())

template <class T> T abs (T x) { re x > 0 ? x : -x; }
template <class T> T sqr (T x) { re x * x; }
template <class T> T gcd (T a, T b) { re a ? gcd (b % a, a) : b; }
template <class T> int sgn (T x) { re x > 0 ? 1 : (x < 0 ? -1 : 0); }

typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<string> vs;
typedef double D;
typedef long double ld;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
typedef unsigned long long ull;
typedef tree <pair<int, char>, null_type, less<pair<int, char>>, rb_tree_tag, tree_order_statistics_node_update> _tree;

int main() {
    cout.precision(10);
    double r, a;
    cin >> a >> r;
    double h = 2 * sqrt(r * r - a * a / 4);
    if (r <= a / 2) cout << pi * r * r / 2 << endl;
    else if (r >= a * sqrt(2) / 2) cout << a * a << endl;
    else cout << pi * r * r + a * h - 2 * r * r * (double)asin(a * h / (2 * r * r)) << endl;
    re 0;
}

Does it mean in this problem h==2  ?

Edited by author 11.11.2017 13:13

/*
by thinking the combinations of the two locks,we get if the password number for lock1 is even or password number for lock2 is odd, the theif could open the lock.

I guess that would be the easiest ideal,right?
*/

#include <iostream>
using namespace std;

int main() {
    int lock1, lock2;
    cin >>lock1 >>lock2;

    if (lock1 % 2 == 0 || lock2 % 2 != 0)
        cout << "yes" << endl;
    else
        cout << "no" << endl;
    return 0;
}

For the classic Josephus problem, there exists two classic algorithms.
The algorithm A has time complexity O(lgn) and comes from <discrete mathematics>.
/* Algorithm A */
int solve(int N/*The magic number 1999*/, int m/*length of the text*/)
{
    long long z = 1;
    while (z < (N - 1LL/*int may overflow here*/) * m + 1)
    {
        z = (z * N + N - 2) / (N - 1);
    }
    return m * N - z;
}

The algorithm B is the classic O(n) algorithm.
int solve(int N/*The magic number 1999*/, int m/*length of the text*/)
{
    int z = 0;
    for (int k = 2; k <= m; ++k)
    {
        z = (z + N) % k;
    }
    return z;
}

In my submissions, algorithm A costs 0.015s, and algorithm B costs 0.001s.
Maybe arithmetic operations for "long long" is a little too slow?

Edited by author 19.02.2016 19:17

#include<bits/stdc++.h>
using namespace std;
typedef struct HeapNode
{
    int *harr;
    int size;
}node;

int leftChild(int n)
{
    return (2*n+1);
}
int rightChild(int n)
{
    return (2*n+2);
}
int getParent(int n)
{
    return (n-1)/2;
}
void maxHeapify(int n,node* nd)
{
    int l=leftChild(n);
    int r=rightChild(n);
    int largest;

    if(l < nd->size && nd->harr[l] > nd->harr[n])
        largest=l;
    else
        largest=n;

    if(r < nd->size && nd->harr[r] > nd->harr[largest])
        largest=r;
    if(largest!=n)
    {
        int t=nd->harr[n];
        nd->harr[n] = nd->harr[largest];
        nd->harr[largest] =t;
        maxHeapify(largest,nd);
    }
}
void buildMaxHeap(node* node)
{
    int i;
    int x=node->size-1;
    x=x/2;
    for(i=x;i>=0;i--)
        {
            maxHeapify(i,node);
        }
}

node* createHeap(int size)
{
    node *n=(node*)malloc(sizeof(node));
    n->size=size;
    n->harr=(int*)malloc(sizeof(int)*size);
}


void addElement(int n,node *nd)
{
    int i=++nd->size;
    nd->harr=(int*)realloc(nd->harr,sizeof(int)*i);
    nd->harr[i-1]=n;
    buildMaxHeap(nd);
}

void deleteAt(int pos,node* nd)
{
    int i;
    nd->harr[pos-1]=nd->harr[nd->size-1];
    --nd->size;
    nd->harr=(int*)realloc(nd->harr,sizeof(int)*nd->size);
    i=pos-1;
    buildMaxHeap(nd);
}

int search(node *nd,int value)
{
        int i=0;
        for(i=0;i<nd->size;i++)
        {
            if(nd->harr[i]==value)
                return i;
        }
}
int peek(node *nd)
{
    return nd->harr[0];
}


int main()
{
    int m;
    cin>>m;
    node * Node=createHeap(m);
    int *arr=(int*)malloc(sizeof(int)*m);
    int *arr2=(int*)malloc(sizeof(int)*50001);
    int n=0;

    int i=0,j=0;
    while (n!=-1 && i<m)
        {
            cin>>n;
            arr[i++]=n;
            arr2[j++]=n;
        }
    Node->harr=arr;
    buildMaxHeap(Node);

    cout<<peek(Node)<<endl;

    int s=search(Node,arr2[0]);
    deleteAt(s+1,Node);

    int c=0,r=m-1;
    while(n!=-1)
    {
        c++;
        cin>>n;
        if(n==-1)break;
        arr2[r+c]=n;
        addElement(n,Node);
        cout<<peek(Node)<<endl;

        s=search(Node,arr2[c]);
        deleteAt(s+1,Node);
    }
    return 0;
}
this is my code... works fine in my compiler... can anyone say what is this access violation error for?

Do you know this content, please?

Why has array
t = new Int16[32000, 32000];
always got a "Runtime Error"? Is "Memory exception in that case?
I dont understand, that this size is incorrect!
I use fenwick tree of two axis dimensions.

Edited by author 15.11.2018 21:11

Edited by author 15.11.2018 21:11

Take care, it does not mean a closed interval.

If you can store the closest base in the same column for each cell, then can you process the solution for each row? Look up "convex hull trick".

If you're stuck think like this, having a directed segment AB, you just need a C among the remaining points s.t. <CBA is acute. Fixing A, is there a way to choose B such that any C among remaining will form acute <CBA ?

That is test 2


Edited by author 14.11.2018 06:18

assc

Edited by author 20.03.2019 19:54

My code gives true answers for all tests but when I send problem it gives WA in test 3. please write answer.

#include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
    ios_base::sync_with_stdio(false);
    cout.tie(0);
    cin.tie(0);
    int n,k;
    cin >> n >> k;
    int dontused=0,dontdie=0;
    int f;
    for(int i=0;i<n;i++)
    {
        cin >> f;
        if(k>f)
        {
            dontdie+=k-f;
        }
        if(k<f)
        {
            dontused+=f-k;
        }
    }
    cout << dontused << " " << dontdie;
    return 0;
}

What is the problem with my code?

#include <iostream>
using namespace std;
#include <cmath>

bool check_prime(double n) {
    int c;
    for (c=2;c<= sqrt(n);c++) {
        if((int) n%c==0)
            return 0;
    }
    if(c==(int) n)
        return 1;
}

int nth_prime(int n){
    int m=1;
    while (n>0) {
        m++;
        if (m == 2) {
            n--;
        }
        if (m%2!=0) {
            if (check_prime(m)==1) {
                n--;
            }
        }
    }
    return m;

}

int main()
{
    int n,m,i,a[15000],s;
    scanf("%d",&n);
    for(i=0;i<n;i++){
        scanf("%d",&a[i]);
    }
    for(i=0;i<n;i++){
        s = nth_prime(a[i]);
        printf("%d\n",s);
    }
    return 0;
}

a=input()
c=0
c+=a.count('a')
c+=a.count('d')
c+=a.count('g')
c+=a.count('j')
c+=a.count('m')
c+=a.count('p')
c+=a.count('s')
c+=a.count('v')
c+=a.count('y')
c+=a.count('y')
c+=a.count('.')
c+=a.count(' ')

c+=a.count('b')*2
c+=a.count('e')*2
c+=a.count('h')*2
c+=a.count('k')*2
c+=a.count('n')*2
c+=a.count('q')*2
c+=a.count('t')*2
c+=a.count('w')*2
c+=a.count('z')*2
c+=a.count(',')*2

c+=a.count('c')*3
c+=a.count('f')*3
c+=a.count('i')*3
c+=a.count('l')*3
c+=a.count('o')*3
c+=a.count('r')*3
c+=a.count('u')*3
c+=a.count('x')*3
c+=a.count('!')*3
print(c)

I can't understand problem in my algorithm. Can it be solved with just Dijkstra?