import java.util.*;

public class MaxBinaryPath {
    static int N;
    static String S;
    static List<Integer>[] adj;
    static boolean[] visited;
    static String maxBinary = "";

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        N = sc.nextInt();

        S = sc.next();

        adj = new ArrayList[N + 1];
        for (int i = 1; i <= N; i++) {
            adj[i] = new ArrayList<>();
        }

        for (int i = 0; i < N - 1; i++) {
            int u = sc.nextInt();
            int v = sc.nextInt();
            adj[u].add(v);
            adj[v].add(u);
        }

        visited = new boolean[N + 1];

        for (int i = 1; i <= N; i++) {
            Arrays.fill(visited, false);
            dfs(i, "");
        }

        int maxLength = N; 
        System.out.println(String.format("%" + maxLength + "s", maxBinary).replace(' ', '0'));

        sc.close();
    }

    private static void dfs(int node, String path) {
        visited[node] = true;
        path += S.charAt(node - 1);

        if (path.length() == N && path.compareTo(maxBinary) > 0) {
            maxBinary = path;
        } else if (path.length() > N) {
            if (path.substring(0, N).compareTo(maxBinary) > 0) {
                maxBinary = path.substring(0, N);
            }
        }

        for (int neighbor : adj[node]) {
            if (!visited[neighbor]) {
                dfs(neighbor, path);
            }
        }

        visited[node] = false;
    }
}

#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int solution(vector<int> &A, vector<int> &B) {
    int N = A.size();
    vector<vector<int>> dp(2, vector<int>(N, 0));
    dp[0][0] = A[0];
    dp[1][0] = max(A[0], B[0]);
   
    for (int j = 1; j < N; ++j) {
        dp[0][j] = max(dp[0][j - 1], A[j]);
        dp[1][j] = min(max(dp[0][j], B[j]), max(dp[1][j - 1], B[j]));
    }
   
    return dp[1][N - 1];
} /// MS TASK 2

Accenture Hiring Tester ❤
Experience : 0 to 2 years

Link to apply 🔗
https://www.accenture.com/in-en/careers/jobdetails?id=ATCI-4366344-S1689605_en&SRC=RECNau

Magna Hiring Data Engineer 🚀

Here's the link 🔗
https://jobs.magna.com/job/Bangalore-Date-Engineer/582228917/

Company: Sideshift.ai
Location: N/A
Role: Junior Backend Engineer
For Graduates: 2023, 2024

https://applicantai.com/sideshift/junior-backend-engineer/8?ref=web3.career#apply

Apply At OpenGig

SDE Intern  - NextJs / NodeJs
Stipend : 20 - 30k fixed
Location : Remote

Form : https://forms.gle/gs8DcYtBjQg8PP6L6

Deloitte hiring Interns

Eligibility : Any Stream / Any Graduate

https://www.linkedin.com/jobs/view/3980132277

Kyndryl is hiring for Application Developer

Bangalore Location
Partically Remote
Bachelors degree required

Apply Fast , this job is posted today !

https://kyndryl.wd5.myworkdayjobs.com/KyndrylProfessionalCareers/job/Bangalore-Karnataka-India/Application-Developer_R-19516-1?source=REC_APPLICANT_SOURCE_LinkedIn

def countIntersections(startsAt, endsAt):
    n = len(startsAt)
    events = []
    for i in range(n):
        events.append((startsAt[i], 'start', i))
        events.append((endsAt[i], 'end', i))
    events.sort(key=lambda x: (x[0], x[1] == 'start'))
    ans = [0] * n
    aa = set()
    for pos, typ, idx in events:
        if typ == 'start':
            ans[idx] += len(aa)
            for active in aa:
                ans[active] += 1
            aa.add(idx)
        elif typ == 'end':
            aa.remove(idx)
    return ans 

Atlassian 2✅

int pre = 0;
const int m = 1e9 + 7;

long long ncr(int n, int r)
{
    if (!pre)
    {
        pre = 1;
        dp[0][0] = 0;
        dp[1][0] = 1;
        dp[1][1] = 1;

        for (int i = 2; i <= 40; i++)
        {
            dp[i][0] = 1;
            for (int j = 1; j < i; j++)
            {
                dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1];
            }
            dp[i][i] = 1;
        }
    }
    return dp[n][r];
}

long long count(long long x)
{
    long long ans = 0;
    long long cnt = 0;
    long long len = 0;
    while (x > 0)
    {
        if (x & 1)
        {
            cnt++;
            ans += ncr(len, cnt);
        }
        len++;
        x >>= 1;
    }
    return ans;
}

unsigned int nextPowerOf2(unsigned int n)
{
    n--;
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;
    n++;
    return n;
}

int solve(int n)
{
    int fn = nextPowerOf2(n) - 1;
    int bc = __builtin_popcount(n);
    int ans = count(n);
    for (int i = n + 1; i < fn; i++)
    {
        if (__builtin_popcount(i) == bc)
            ans = (ans + 1) % m;
    }
    return ans;
}

 

Atlassian 1✅

Mindtree milestone internal Exam Cleared OA