<p>There are <code>n</code> <strong>1-indexed</strong> robots, each having a position on a line, health, and movement direction.</p>

<p>You are given <strong>0-indexed</strong> integer arrays <code>positions</code>, <code>healths</code>, and a string <code>directions</code> (<code>directions[i]</code> is either <strong>&#39;L&#39;</strong> for <strong>left</strong> or <strong>&#39;R&#39;</strong> for <strong>right</strong>). All integers in <code>positions</code> are <strong>unique</strong>.</p>

<p>All robots start moving on the line<strong> simultaneously</strong> at the <strong>same speed </strong>in their given directions. If two robots ever share the same position while moving, they will <strong>collide</strong>.</p>

<p>If two robots collide, the robot with <strong>lower health</strong> is <strong>removed</strong> from the line, and the health of the other robot <strong>decreases</strong> <strong>by one</strong>. The surviving robot continues in the <strong>same</strong> direction it was going. If both robots have the <strong>same</strong> health, they are both<strong> </strong>removed from the line.</p>

<p>Your task is to determine the <strong>health</strong> of the robots that survive the collisions, in the same <strong>order </strong>that the robots were given,<strong> </strong>i.e. final health of robot 1 (if survived), final health of robot 2 (if survived), and so on. If there are no survivors, return an empty array.</p>

<p>Return <em>an array containing the health of the remaining robots (in the order they were given in the input), after no further collisions can occur.</em></p>

<p><strong>Note:</strong> The positions may be unsorted.</p>

<div class="notranslate" style="all: initial;">&nbsp;</div>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<p><img height="169" src="https://assets.leetcode.com/uploads/2023/05/15/image-20230516011718-12.png" width="808" /></p>

<pre>
<strong>Input:</strong> positions = [5,4,3,2,1], healths = [2,17,9,15,10], directions = &quot;RRRRR&quot;
<strong>Output:</strong> [2,17,9,15,10]
<strong>Explanation:</strong> No collision occurs in this example, since all robots are moving in the same direction. So, the health of the robots in order from the first robot is returned, [2, 17, 9, 15, 10].
</pre>

<p><strong class="example">Example 2:</strong></p>

<p><img height="176" src="https://assets.leetcode.com/uploads/2023/05/15/image-20230516004433-7.png" width="717" /></p>

<pre>
<strong>Input:</strong> positions = [3,5,2,6], healths = [10,10,15,12], directions = &quot;RLRL&quot;
<strong>Output:</strong> [14]
<strong>Explanation:</strong> There are 2 collisions in this example. Firstly, robot 1 and robot 2 will collide, and since both have the same health, they will be removed from the line. Next, robot 3 and robot 4 will collide and since robot 4&#39;s health is smaller, it gets removed, and robot 3&#39;s health becomes 15 - 1 = 14. Only robot 3 remains, so we return [14].
</pre>

<p><strong class="example">Example 3:</strong></p>

<p><img height="172" src="https://assets.leetcode.com/uploads/2023/05/15/image-20230516005114-9.png" width="732" /></p>

<pre>
<strong>Input:</strong> positions = [1,2,5,6], healths = [10,10,11,11], directions = &quot;RLRL&quot;
<strong>Output:</strong> []
<strong>Explanation:</strong> Robot 1 and robot 2 will collide and since both have the same health, they are both removed. Robot 3 and 4 will collide and since both have the same health, they are both removed. So, we return an empty array, [].</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= positions.length == healths.length == directions.length == n &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= positions[i], healths[i] &lt;= 10<sup>9</sup></code></li>
	<li><code>directions[i] == &#39;L&#39;</code> or <code>directions[i] == &#39;R&#39;</code></li>
	<li>All values in <code>positions</code> are distinct</li>
</ul>

class Solution {
public:
    vector<int> survivedRobotsHealths(vector<int>& posn, vector<int>& health, string dirn) {
        unordered_map<int,int>index;
        int n=posn.size();
        for(int i=0;i<n;i++){
            index[posn[i]]=i;
        }//keeping track of original index with respect to position
        sort(posn.begin(),posn.end());
        vector<int>newHealth;
        vector<bool> newDirn;

        for(int i=0;i<n;i++){
            int temp=posn[i];
            int ind=index[temp];
            newHealth.push_back(health[ind]);
            if(dirn[ind]=='L')newDirn.push_back(1);
            else newDirn.push_back(0);
        }//making rearraging health and direction according to the new sorted position array

        stack<pair<int,int>>s;
        s.push({0,newHealth[0]});
        for(int i=1;i<n;i++){
            int h=newHealth[i];
            bool disha=newDirn[i];
            int index=i;
            if(s.empty()){//if stack is empty then no collision can happen
                s.push({index,h});
                continue;
            }
            int prevH=s.top().second;
            int prevIndex=s.top().first;
            bool prevDisha=newDirn[prevIndex];

            if(prevDisha==disha || (prevDisha==1 && disha==0)){//if travelling in same diection or opposite direction but in outward direction the no collision
                //no collision
                //cout<<"No collition between "<<index<<" and "<<prevIndex<<endl;
                s.push({index,h});
                continue;
            }
            else{
                //collision
                bool flag=false;
                while(!s.empty() && disha==1 && prevDisha==0){//jab tk stack mei koi bhi robot aisa h jo ki collision kr skta h ya phir stack empty nhi hota
                    s.pop();
                    flag=false;//ek case h jisme agr dono ki health same h to koi bhi nya push nhi krna sirf pop krna h last robot ko , to yeh track rkhne ke liye ki humme koi push krna h ye nhi iske liye flag use kra h 
                    //cout<<"collision occured "<<h<<" "<<prevH<<" ";
                    if(h==prevH)break;//no pushing

                    else if(h>prevH && h-1>0){
                        h--;//current robot strong h , aur uski health minus krke usse hi maintain krna h current pr
                        flag=true;//pushing
                        if(!s.empty()){//previous robot update krdo agr stack empty nhi h to
                            prevIndex=s.top().first;
                            prevH=s.top().second;
                            prevDisha=newDirn[prevIndex];
                        }
                    }

                    else{//previous robot strong h, aise mei previous robot ko current robot ke stats se replace krdo kyunki humme previous robot ki health -1 krke waps push krne h 
                        flag=true;//pushing
                        h=prevH-1;
                        disha=prevDisha;
                        index=prevIndex;
                        break;
                    }
                }
                //cout<<"pushing "<<index<<endl;
                if(flag)s.push({index,h});
            } 
        }
        vector<pair<int,int>>ans;
        while(!s.empty()){
            int ind=s.top().first;//new index of robot
            int key=posn[ind];//finding position of robot according to new index
            int originalIndex=index[key];//finding original index according to its index, mapped at the begining
            ans.push_back({originalIndex,s.top().second});
            s.pop();
        }
        sort(ans.begin(),ans.end());//sorting according to original index
        vector<int>result;
        for(auto i:ans){//storing updated health
            result.push_back(i.second);
        }
        return result;
        


    }
};
240641