Find the final radiations of each Radiated Stations

There are N stations in a straight line, each of them has some non-negative radiation power. Every station can increase the radiation power of its neighbouring stations in the following way,
Station i with radiation power R will increase (i – 1)th station’s radiation by R – 1, (i – 2)th station’s radiation by R – 2, so on… and (i + 1)th station’s radiation by R – 1, (i + 2)th station’s radiation by R – 2, so on… upto when the effective radiation power is positive.
The task is to find the final radiations for each of the stations.

Examples:

Input: arr[] = {1, 2, 3}
Output: 3 4 4
The new radiation will be {1 + (2 – 1) + (3 – 2), 2 + (1 – 1) + (3 – 1), 3 + (2 – 1)}
i.e. {3, 4, 4}

Input: arr[] = {9, 87, 55, 2, 1}
Output: 148 149 149 147 144

Input: arr[] = {7, 9, 12, 2, 5}
Output: 26 28 29 28 25

Naive Approach: For each station i increase the radiation of the neighbour stations as mentioned above upto when the effective radiation become negative.
Time Complexity: O(n*n)

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to print the final radiations
void print(int rStation[], int n)
{
    for (int i = 1; i <= n; i++)
        cout << rStation[i] << " ";
    cout << endl;
}
  
// Function to create the array of the
// resultant radiations
void radiated_Station(int station[], int n)
{
  
    // Resultant radiations
    int rStation[n + 1];
  
    // Initialize resultant array with 0
    memset(rStation, 0, sizeof(rStation));
  
    for (int i = 1; i <= n; i++) {
  
        // Declaring index counter for left
        // and right radiation
        int li = i - 1, ri = i + 1;
  
        // Effective radiation for left
        // and right case
        int lRad = station[i] - 1, rRad = station[i] - 1;
  
        // Radiation for i-th station
        rStation[i] += station[i];
  
        // Radiation increment for left stations
        while (li >= 1 && lRad >= 1) {
            rStation[li--] += lRad--;
        }
  
        // Radiation increment for right stations
        while (ri <= n && rRad >= 1) {
            rStation[ri++] += rRad--;
        }
    }
  
    // Print the resultant radiation
    // for each of the stations
    print(rStation, n);
}
  
// Driver code
int main()
{
  
    // 1-based indexing
    int station[] = { 0, 7, 9, 12, 2, 5 };
    int n = (sizeof(station) / sizeof(station[0])) - 1;
  
    radiated_Station(station, n);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
class GFG {
  
    // Function to print the final radiations
    static void print(int rStation[], int n)
    {
        for (int i = 1; i <= n; i++)
            System.out.print(rStation[i] + " ");
        System.out.println("");
    }
  
    // Function to create the array of the
    // resultant radiations
    static void radiated_Station(int station[], int n)
    {
  
        // Resultant radiations
        int rStation[] = new int[n + 1];
  
        for (int i = 1; i <= n; i++) {
  
            // Declaring index counter for left
            // and right radiation
            int li = i - 1, ri = i + 1;
  
            // Effective radiation for left
            // and right case
            int lRad = station[i] - 1, rRad = station[i] - 1;
  
            // Radiation for i-th station
            rStation[i] += station[i];
  
            // Radiation increment for left stations
            while (li >= 1 && lRad >= 1) {
                rStation[li--] += lRad--;
            }
  
            // Radiation increment for right stations
            while (ri <= n && rRad >= 1) {
                rStation[ri++] += rRad--;
            }
        }
  
        // Print the resultant radiation
        // for each of the stations
        print(rStation, n);
    }
  
    // Driver code
    public static void main(String[] args)
    {
        // 1-based indexing
        int station[] = { 0, 7, 9, 12, 2, 5 };
        int n = station.length - 1;
  
        radiated_Station(station, n);
    }
}
  
// This code has been contributed by 29AjayKumar

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 implementation of the approach
  
# Function to print the final radiations
def printf(rStation, n):
    for i in range(1, n + 1, 1):
        print(rStation[i], end = " ")
    print("\n", end = " ")
  
# Function to create the array of the
# resultant radiations
def radiated_Station(station, n):
      
    # Resultant radiations
    rStation = [0 for i in range(n + 1)]
  
    for i in range(1, n + 1):
        # Declaring index counter for left
        # and right radiation
        li = i - 1
        ri = i + 1
  
        # Effective radiation for left
        # and right case
        lRad = station[i] - 1
        rRad = station[i] - 1
  
        # Radiation for i-th station
        rStation[i] += station[i]
  
        # Radiation increment for left stations
        while (li >= 1 and lRad >= 1):
            rStation[li] += lRad
            lRad -= 1
            li -= 1
  
        # Radiation increment for right stations
        while (ri <= n and rRad >= 1):
            rStation[ri] += rRad
            rRad -= 1
            ri += 1
  
    # Print the resultant radiation
    # for each of the stations
    printf(rStation, n)
  
# Driver code
if __name__ == '__main__':
    # 1-based indexing
    station = [0, 7, 9, 12, 2, 5]
    n = len(station) - 1
  
    radiated_Station(station, n)
      
# This code is contributed by
# Surendra_Gangwar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System;
  
class GFG {
  
    // Function to print the final radiations
    static void print(int[] rStation, int n)
    {
        for (int i = 1; i <= n; i++)
            Console.Write(rStation[i] + " ");
        Console.WriteLine("");
    }
  
    // Function to create the array of the
    // resultant radiations
    static void radiated_Station(int[] station, int n)
    {
  
        // Resultant radiations
        int[] rStation = new int[n + 1];
  
        for (int i = 1; i <= n; i++) {
  
            // Declaring index counter for left
            // and right radiation
            int li = i - 1, ri = i + 1;
  
            // Effective radiation for left
            // and right case
            int lRad = station[i] - 1, rRad = station[i] - 1;
  
            // Radiation for i-th station
            rStation[i] += station[i];
  
            // Radiation increment for left stations
            while (li >= 1 && lRad >= 1) {
                rStation[li--] += lRad--;
            }
  
            // Radiation increment for right stations
            while (ri <= n && rRad >= 1) {
                rStation[ri++] += rRad--;
            }
        }
  
        // Print the resultant radiation
        // for each of the stations
        print(rStation, n);
    }
  
    // Driver code
    public static void Main(String[] args)
    {
        // 1-based indexing
        int[] station = { 0, 7, 9, 12, 2, 5 };
        int n = station.Length - 1;
  
        radiated_Station(station, n);
    }
}
  
/* This code contributed by PrinciRaj1992 */

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of the approach
   
// Function to print the final radiations
  
function print_radiation($rStation, $n)
{
    for ($i = 1; $i <= $n; $i++)
    {
        echo $rStation[$i]." ";
    }
    echo "\n";
}
  
// Function to create the array of the
// resultant radiations
function radiated_Station($station, $n)
{
   
    // Resultant radiations
    $rStation  = array();
   
    // Initialize resultant array with 0
    $rStation = array_fill(0, $n+1, 0);
   
    for ($i = 1; $i <= $n; $i++) {
   
        // Declaring index counter for left
        // and right radiation
        $li = $i - 1;
        $ri = $i + 1;
   
        // Effective radiation for left
        // and right case
        $lRad = $station[$i] - 1;
        $rRad = $station[$i] - 1;
   
        // Radiation for i-th station
        $rStation[$i] += $station[$i];
   
        // Radiation increment for left stations
        while ($li >= 1 && $lRad >= 1) {
            $rStation[$li--] += $lRad--;
        }
   
        // Radiation increment for right stations
        while ($ri <= $n && $rRad >= 1) {
            $rStation[$ri++] += $rRad--;
        }
    }
   
    // Print the resultant radiation
    // for each of the stations
    print_radiation($rStation, $n);
}
   
// Driver code
  
// 1-based indexing
$station = array( 0, 7, 9, 12, 2, 5 );
$n = (sizeof($station) / sizeof($station[0])) - 1;
  
radiated_Station($station, $n);
  
//code contributed by Shashank_Sharma
?>

chevron_right


Output:

26 28 29 28 25

Efficient Approach:

  • For each station we’ll calculate its extreme left and right radiation effects separately.
  • Then two iterations one from left another from right will construct two arrays.
  • Left iteration will construct array left_Rad[] that is made of each station’s left effective radiation and right_Rad[] will be constructed by the Right iteration.
  • For station i let us assume it will be effected by m number of stations’ left radiation and n number of stations’ right radiation. we need another arrays lCount[] for the m values and rcount[] for n values.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to print the final radiations
void print(int rStation[], int n)
{
    for (int i = 1; i <= n; i++)
        cout << rStation[i] << " ";
    cout << endl;
}
  
// Function to create the array of the
// resultant radiations
void radiated_Station(int station[], int n)
{
  
    // Resultant radiations
    int rStation[n + 1];
  
    int left_Rad[n + 2], right_Rad[n + 2];
  
    // Frequency of stations that affect each station
    int lCount[n + 2], rCount[n + 2];
  
    // Initialization of the arrays with 0
    memset(left_Rad, 0, sizeof(left_Rad));
    memset(right_Rad, 0, sizeof(right_Rad));
    memset(lCount, 0, sizeof(lCount));
    memset(rCount, 0, sizeof(rCount));
  
    for (int i = 1; i < n + 1; i++) {
  
        // Radiation of station i
        int Rad = station[i];
  
        // Left and right most position of radiation
        // for station i, index should be
        // in between the station range
        int li = max(1, i - Rad + 1), ri = min(n, Rad - 1 + i);
  
        // At station 1 radiation effect
        // for station i
        int at1 = max(0, Rad - i + 1);
        left_Rad[1] += at1;
  
        // While iterating from left avoid
        // effective radiation at right
        left_Rad[i + 1] -= Rad;
  
        // At station n radiation effect
        // for station i
        int atn = max(0, Rad - n + i);
        right_Rad[n] += atn;
  
        // While iterating from right avoid
        // effective radiation at left
        right_Rad[i - 1] -= Rad;
  
        // Left and right most position
        // where station i effects
        lCount[li]++;
        rCount[ri]++;
  
        // Avoiding right radiation for
        // left iteration and vice-versa
        lCount[i + 1]--;
        rCount[i - 1]--;
    }
  
    // Left iteration
    for (int i = 1; i <= n; i++) {
        lCount[i] += lCount[i - 1];
  
        // Total radiations at index 1 already counted
        if (i > 1)
            left_Rad[i] += left_Rad[i - 1] + lCount[i];
    }
  
    // Right iteration
    for (int i = n; i >= 1; i--) {
        rCount[i] += rCount[i + 1];
  
        // Total radiations at index n already counted
        if (i < n)
            right_Rad[i] += right_Rad[i + 1] + rCount[i];
    }
  
    // Final iteration that creates
    // the resultant radiation
    for (int i = 1; i <= n; i++) {
  
        // Added extra value in each index
        rStation[i] = left_Rad[i] + right_Rad[i] - station[i];
    }
  
    // Print the resultant radiation
    // for each of the stations
    print(rStation, n);
}
  
// Driver code
int main()
{
  
    // 1-based indexing
    int station[] = { 0, 7, 9, 12, 2, 5 };
    int n = (sizeof(station) / sizeof(station[0])) - 1;
  
    radiated_Station(station, n);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
class GFG {
  
    // Function to print the final radiations
    static void print(int rStation[], int n)
    {
        for (int i = 1; i <= n; i++)
            System.out.print(rStation[i] + " ");
        System.out.println("");
    }
  
    // Function to create the array of the
    // resultant radiations
    static void radiated_Station(int station[], int n)
    {
  
        // Resultant radiations
        int[] rStation = new int[n + 1];
  
        int[] left_Rad = new int[n + 2];
        int[] right_Rad = new int[n + 2];
  
        // Frequency of stations that affect each station
        int[] lCount = new int[n + 2];
        int[] rCount = new int[n + 2];
  
        for (int i = 1; i < n + 1; i++) {
  
            // Radiation of station i
            int Rad = station[i];
  
            // Left and right most position of radiation
            // for station i, index should be
            // in between the station range
            int li = Math.max(1, i - Rad + 1), ri = Math.min(n, Rad - 1 + i);
  
            // At station 1 radiation effect
            // for station i
            int at1 = Math.max(0, Rad - i + 1);
            left_Rad[1] += at1;
  
            // While iterating from left avoid
            // effective radiation at right
            left_Rad[i + 1] -= Rad;
  
            // At station n radiation effect
            // for station i
            int atn = Math.max(0, Rad - n + i);
            right_Rad[n] += atn;
  
            // While iterating from right avoid
            // effective radiation at left
            right_Rad[i - 1] -= Rad;
  
            // Left and right most position
            // where station i effects
            lCount[li]++;
            rCount[ri]++;
  
            // Avoiding right radiation for
            // left iteration and vice-versa
            lCount[i + 1]--;
            rCount[i - 1]--;
        }
  
        // Left iteration
        for (int i = 1; i <= n; i++) {
            lCount[i] += lCount[i - 1];
  
            // Total radiations at index 1 already counted
            if (i > 1)
                left_Rad[i] += left_Rad[i - 1] + lCount[i];
        }
  
        // Right iteration
        for (int i = n; i >= 1; i--) {
            rCount[i] += rCount[i + 1];
  
            // Total radiations at index n already counted
            if (i < n)
                right_Rad[i] += right_Rad[i + 1] + rCount[i];
        }
  
        // Final iteration that creates
        // the resultant radiation
        for (int i = 1; i <= n; i++) {
  
            // Added extra value in each index
            rStation[i] = left_Rad[i] + right_Rad[i] - station[i];
        }
  
        // Print the resultant radiation
        // for each of the stations
        print(rStation, n);
    }
  
    // Driver code
    public static void main(String[] args)
    {
        // 1-based indexing
        int station[] = { 0, 7, 9, 12, 2, 5 };
        int n = station.length - 1;
  
        radiated_Station(station, n);
    }
}
  
// This code contributed by Rajput-Ji

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System;
  
class GFG {
  
    // Function to print the final radiations
    static void print(int[] rStation, int n)
    {
        for (int i = 1; i <= n; i++)
            Console.Write(rStation[i] + " ");
        Console.WriteLine("");
    }
  
    // Function to create the array of the
    // resultant radiations
    static void radiated_Station(int[] station, int n)
    {
  
        // Resultant radiations
        int[] rStation = new int[n + 1];
  
        int[] left_Rad = new int[n + 2];
        int[] right_Rad = new int[n + 2];
  
        // Frequency of stations that affect each station
        int[] lCount = new int[n + 2];
        int[] rCount = new int[n + 2];
  
        for (int i = 1; i < n + 1; i++) {
  
            // Radiation of station i
            int Rad = station[i];
  
            // Left and right most position of radiation
            // for station i, index should be
            // in between the station range
            int li = Math.Max(1, i - Rad + 1),
                ri = Math.Min(n, Rad - 1 + i);
  
            // At station 1 radiation effect
            // for station i
            int at1 = Math.Max(0, Rad - i + 1);
            left_Rad[1] += at1;
  
            // While iterating from left avoid
            // effective radiation at right
            left_Rad[i + 1] -= Rad;
  
            // At station n radiation effect
            // for station i
            int atn = Math.Max(0, Rad - n + i);
            right_Rad[n] += atn;
  
            // While iterating from right avoid
            // effective radiation at left
            right_Rad[i - 1] -= Rad;
  
            // Left and right most position
            // where station i effects
            lCount[li]++;
            rCount[ri]++;
  
            // Avoiding right radiation for
            // left iteration and vice-versa
            lCount[i + 1]--;
            rCount[i - 1]--;
        }
  
        // Left iteration
        for (int i = 1; i <= n; i++) {
            lCount[i] += lCount[i - 1];
  
            // Total radiations at index 1 already counted
            if (i > 1)
                left_Rad[i] += left_Rad[i - 1] + lCount[i];
        }
  
        // Right iteration
        for (int i = n; i >= 1; i--) {
            rCount[i] += rCount[i + 1];
  
            // Total radiations at index n already counted
            if (i < n)
                right_Rad[i] += right_Rad[i + 1] + rCount[i];
        }
  
        // Final iteration that creates
        // the resultant radiation
        for (int i = 1; i <= n; i++) {
  
            // Added extra value in each index
            rStation[i] = left_Rad[i] + right_Rad[i] - station[i];
        }
  
        // Print the resultant radiation
        // for each of the stations
        print(rStation, n);
    }
  
    // Driver code
    public static void Main(String[] args)
    {
        // 1-based indexing
        int[] station = { 0, 7, 9, 12, 2, 5 };
        int n = station.Length - 1;
  
        radiated_Station(station, n);
    }
}
  
/* This code contributed by PrinciRaj1992 */

chevron_right


Output:

26 28 29 28 25


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.