Ticket.com is hiring SDE I (Backend)

For 2023, 2024, 2025 grads
Location: Noida

https://jobs.lever.co/tiket/36caec4f-182b-4132-b3ef-a2e18446cf38/

🏢 HBWSL – Software Developer Intern 
📍 Location: Not specified 
🎓 Eligible Batch: 2026 

🔗 Apply Now: 
https://forms.gle/xjYBhMhfjwvozDKn8 

🔗 Reference HR LinkedIn: 
https://www.linkedin.com/posts/bhavana-tambe-64109337_hbwsl-software-developer-intern-activity-7349415180205703168-H_px 

 
🙌 Share with your friends & juniors!

Hey LinkedIn professionals,

I know how difficult it is for freshers to land a job in today's market. 🧐 So, Dexian has come up with an excellent Work from home Opportunity. Yes, you heard that right! A work from home opportunity with a top e-commerce giant! 💻

✅ The best part? Graduates from any field can apply! (2023,2024 graduates only)
Please reach out to me at sandeepana.chakra@dexian.com 🚀 or you can DM me on LinkedIn to discuss further!! 🙂

One interested comment will also fly; I will reach out to you. 😎
✅ Role: Catalog Specialist
✅ Mode: Work from Home.

https://careers.mccain.com/us/en/job/MFOMFBUS37102EXTERNALENUS/Software-Development-Engineer

2024 and 25 batch✅

UiPath hiring ML Engineer

2023/2024/2025 grads
Location : Jaipur

Apply Link : https://jobs.ashbyhq.com/uipath/72b31ba5-168c-4edc-983a-e9a9a0c508c8

Company Name: Baker Huges
Batch: 2025 passouts
Role: Software Engineer
Link: https://careers.bakerhughes.com/global/en/job/BAHUGLOBALR128487/Early-Career-ASPIRE-Engineering-and-Technology-India-2025-Opportunities

BNP Paribas hiring Associate Level l

0-2 year experience

Apply Link : https://group.bnpparibas/en/careers/job-offer/associate-level-1-8?SRC=LINKEDIN

#include <bits/stdc++.h>
using namespace std;

int main(){
  
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N, Smax;
    if(!(cin >> N >> Smax)) return 0;
    vector<char> id(N);
    vector<int> E(N), R(N);
    for(int i = 0; i < N; i++){
        cin >> id[i] >> E[i] >> R[i];
    }

    vector<vector<int>> dp(N+1, vector<int>(Smax+1, 0));
    for(int i = 1; i <= N; i++){
        for(int w = 0; w <= Smax; w++){
            dp[i][w] = dp[i-1][w];
            if(w >= E[i-1])
                dp[i][w] = max(dp[i][w], dp[i-1][w - E[i-1]] + R[i-1]);
        }
    }

    int bestReward = dp[N][Smax];
    if(bestReward == 0){
        cout << -1 << "\n";
        return 0;
    }

    vector<int> chosen;
    int w = Smax;
    for(int i = N; i >= 1; i--){
        if(dp[i][w] != dp[i-1][w]){
            // task i-1 was used
            chosen.push_back(i-1);
            w -= E[i-1];
        }
    }
    reverse(chosen.begin(), chosen.end()); 

    int totalEffort = 0;
    for(int idx : chosen) totalEffort += E[idx];

    for(size_t i = 0; i < chosen.size(); i++){
        if(i) cout << ' ';
        cout << id[chosen[i]];
    }
    cout << "\n";
    cout << totalEffort << ' ' << bestReward << "\n";
    return 0;
}

#include <iostream>
#include <vector>
#include <unordered_map>
#include <climits>
using namespace std;

int budget;
vector<int> bestpath;

void dfs(int curr, int spent, unordered_map<int, vector<pair<int, int>>> &graph,
         vector<bool> &visited, vector<int> &path, vector<int> &retCost) {
    if (curr == 1 && path.size() > 1 && spent <= budget) {
        if (path.size() > bestpath.size()) {
            bestpath = path;
        }
    }
    for (auto &[nei, cost] : graph[curr]) {
        int total = spent + cost + (nei == 1 ? 0 : retCost[nei]);
        if ((!visited[nei] || (nei == 1 && path.size() > 1)) && total <= budget) {
            bool was = visited[nei];
            visited[nei] = true;
            path.push_back(nei);
            dfs(nei, spent + cost, graph, visited, path, retCost);
            path.pop_back();
            if (!was) visited[nei] = false;
        }
    }
}

vector<int> dijkstra(int n, unordered_map<int, vector<pair<int, int>>> &graph) {
    vector<int> dist(n + 1, INT_MAX);
    vector<bool> visited(n + 1, false);
    dist[1] = 0;

    for (int i = 1; i <= n; ++i) {
        int u = -1;
        for (int j = 1; j <= n; ++j)
            if (!visited[j] && (u == -1 || dist[j] < dist[u]))
                u = j;
        if (dist[u] == INT_MAX) break;
        visited[u] = true;
        for (auto &[v, w] : graph[u]) {
            if (dist[v] > dist[u] + w)
                dist[v] = dist[u] + w;
        }
    }
    return dist;
}

void optimalPath(int N, int M, int price, int *source, int *dest, int *weight) {
    unordered_map<int, vector<pair<int, int>>> graph;
    budget = price;
    bestpath.clear();

    for (int i = 0; i < M; ++i) {
        graph[source[i]].push_back({dest[i], weight[i]});
        graph[dest[i]].push_back({source[i], weight[i]});
    }

    vector<int> retCost = dijkstra(N, graph);
    vector<bool> visited(N + 1, false);
    vector<int> path = {1};
    visited[1] = true;

    dfs(1, 0, graph, visited, path, retCost);

    for (int v : bestpath)
        cout << v << " ";
    cout << endl;
}