1783D - Different Arrays - CodeForces Solution


brute force dp implementation

Please click on ads to support us..

Python Code:

def main():

    MOD = 998244353
    n = int(input())
    a = readIntArr()

        
        offset = 100000
    dp = [0] * 200000      dp[offset + a[1]] = 1
    for i in range(1, n - 1):
                dp2 = [0] * 200000
        for v in range(-90000, 90000):
            if -100000 < a[i + 1] + v < 100000:
                dp2[offset + a[i + 1] + v] = (dp2[offset + a[i + 1] + v] + dp[offset + v]) % MOD
            if v != 0 and -100000 < a[i + 1] - v < 100000:
                dp2[offset + a[i + 1] - v]
                dp2[offset + a[i + 1] - v] = (dp2[offset + a[i + 1] - v] + dp[offset + v]) % MOD
        dp = dp2
    ans = 0
    for cnts in dp:
        ans += cnts
        ans %= MOD
    print(ans)

        
    return

import sys
input=sys.stdin.buffer.readline  
def oneLineArrayPrint(arr):
    print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
    print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
    print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
 
def readIntArr():
    return [int(x) for x in input().split()]
 
def makeArr(defaultValFactory,dimensionArr):     dv=defaultValFactory;da=dimensionArr
    if len(da)==1:return [dv() for _ in range(da[0])]
    else:return [makeArr(dv,da[1:]) for _ in range(da[0])]
 
def queryInteractive(a, b):
    print('? {} {}'.format(a, b))
    sys.stdout.flush()
    return int(input())
 
def answerInteractive(ans):
    print('! {}'.format(ans))
    sys.stdout.flush()
 
inf=float('inf')
 
from math import gcd,floor,ceil
import math
 
for _abc in range(1):
    main()

C++ Code:

#include <bits/stdc++.h>
#include<fstream>
using namespace std;
#define MAX 100'005
#define pii pair<int, int>
#define ll long long
#define pll pair<ll, ll>
#define tii tuple<int, int, int>
#define tiii tuple<int, int, int, int>
const int MOD = 998244353;

int a[301][301*301*2];

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int tt = 1;
//    ifstream fin;
//    fin.open("input.txt");
//    cout<<fixed;
//    cout.precision(15);
//    cin >> tt;
    while(tt--) {
        int n;
        cin >> n;
        vector<int> v(n);
        for(int i=0; i<n; i++){
            cin >> v[i];
        }
        a[1][v[1]+300*301]=1;
        for(int i=1; i<n-1; i++){
            for(int j=0; j<301*301*2; j++){
                if(a[i][j]>0){
                    int x = j-301*300;
                    if(x == 0){
                        a[i+1][v[i+1]+300*301]=(a[i+1][v[i+1]+300*301]+a[i][j])%MOD;
                    }
                    else{
                        a[i+1][v[i+1]+x+300*301] = (a[i+1][v[i+1]+x+300*301]+a[i][j])%MOD;
                        a[i+1][v[i+1]-x+300*301] = (a[i+1][v[i+1]-x+300*301]+a[i][j])%MOD;
                    }
                }
            }
        }
        ll ans = 0;
        for(int i=0; i<301*301*2; i++){
            if(a[n-1][i]>0){
                ans = (ans+a[n-1][i])%MOD;
            }
        }
        cout << ans << '\n';
    }
}


Comments

Submit
0 Comments
More Questions

1302. Deepest Leaves Sum
1209. Remove All Adjacent Duplicates in String II
994. Rotting Oranges
983. Minimum Cost For Tickets
973. K Closest Points to Origin
969. Pancake Sorting
967. Numbers With Same Consecutive Differences
957. Prison Cells After N Days
946. Validate Stack Sequences
921. Minimum Add to Make Parentheses Valid
881. Boats to Save People
497. Random Point in Non-overlapping Rectangles
528. Random Pick with Weight
470. Implement Rand10() Using Rand7()
866. Prime Palindrome
1516A - Tit for Tat
622. Design Circular Queue
814. Binary Tree Pruning
791. Custom Sort String
787. Cheapest Flights Within K Stops
779. K-th Symbol in Grammar
701. Insert into a Binary Search Tree
429. N-ary Tree Level Order Traversal
739. Daily Temperatures
647. Palindromic Substrings
583. Delete Operation for Two Strings
518. Coin Change 2
516. Longest Palindromic Subsequence
468. Validate IP Address
450. Delete Node in a BST