thảo luận Leetcode mỗi ngày

class Solution {
public:

    pair<int, int> ChangeState(int dX, int dY, int d) {
        if (d == -2) {
            if (dX == 0 && dY == 1) return make_pair(-1, 0);   
            if (dX == -1 && dY == 0) return make_pair(0, -1);
            if (dX == 0 && dY == -1) return make_pair(1, 0);
            if (dX == 1 && dY == 0) return make_pair(0, 1);
        } else if (d == -1) {
            if (dX == 0 && dY == 1) return make_pair(1, 0);
            if (dX == 1 && dY == 0) return make_pair(0, -1);
            if (dX == 0 && dY == -1) return make_pair(-1, 0);
            if (dX == -1 && dY == 0) return make_pair(0, 1);
        }
        return make_pair(dX, dY);
    }

    int robotSim(vector<int>& commands, vector<vector<int>>& obstacles) {
        int dX = 0, dY = 1;
        int x = 0, y = 0;
        set<pair<int,int>> isOb;
        for(vector coord: obstacles){
            isOb.insert(make_pair(coord[0],coord[1]));
        }
        int maxDis = 0;
        int dis = 0;
        for(int c: commands){
            if(c >= 0){
                for(int step = 1;step <= c;step++){
                    if(isOb.count(make_pair(x + dX,y + dY)) > 0) break;
                    x += dX;
                    y += dY;
                    dis = x * x + y * y;
                    maxDis = dis > maxDis ? dis : maxDis;
                }
            }else {
                pair<int,int> direction = ChangeState(dX,dY,c);
                dX = direction.first;
                dY = direction.second;
            }
        }
        return maxDis;
    }
};

class Solution {
    List<String> ans;
    int n;
    public List<String> restoreIpAddresses(String s) {
        n = s.length();
        ans = new ArrayList<>();
        backtrack(0, 0, 0, "", s);
        return ans;
    }

    private void backtrack(int idx, int dots, int curNum, String curStr, String s) {
        int l = curStr.length();
        if (curNum > 255) return;
        if (idx == n) {
            if (dots == 3 && curStr.charAt(l - 1) != '.') ans.add(curStr);
            if (dots == 4 && curStr.substring(l - 3, l).equals(".0.")) ans.add(curStr.substring(0, l - 1));
            return;
        }

        char d = s.charAt(idx);
        int dInt = (int) (d - '0');

        if (d == '0' && (idx == 0 || curStr.charAt(curStr.length() - 1) == '.')) {
            backtrack(idx + 1, dots + 1, 0, curStr + d + ".", s);
        } else if (curNum * 10 + dInt <= 255){
            backtrack(idx + 1, dots + 1, 0, curStr + d + ".", s);
            backtrack(idx + 1, dots, curNum * 10 + dInt, curStr + d, s);
        }
    }
}

public class Solution
{
    public int RobotSim(int[] commands, int[][] obstacles)
    {
        HashSet<(int,int)> obs = new();
        for (int i = 0; i < obstacles.Length; i++)
        {
            obs.Add((obstacles[i][0], obstacles[i][1]));
        }

        int[][] dirs = [[0, 1], [1, 0], [0, -1], [-1, 0]];

        int currDirIndex = 0;
        (int, int) coord = (0, 0);
        int maxDist = 0;
        for (int i = 0; i < commands.Length; i++)
        {
            int command = commands[i];
            if (command == -1)
            {
                currDirIndex = (currDirIndex + 1) % 4;
                continue;
            }
            if (command == -2)
            {
                currDirIndex = ((currDirIndex - 1) % 4 + 4) % 4;
                continue;
            }

            int[] dir = dirs[currDirIndex];
            for (int step = 0; step < command; step++)
            {
                int x = coord.Item1 + dir[0];
                int y = coord.Item2 + dir[1];
                if (obs.Contains((x, y)))
                {
                    break;
                }
                coord.Item1 = x;
                coord.Item2 = y;
                maxDist = Math.Max(maxDist, x * x + y * y);
            }

        }

        return maxDist;
    }
}

class Solution:
    def robotSim(self, C: List[int], O: List[List[int]]) -> int:
        obstacles = set(map(tuple, O))
        directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
        x, y = 0, 0  
        direction = 0  
        
        max_distance = 0
        
        for c in C:
            if c == -1:  # Turn right
                direction = (direction + 1) % 4
            elif c == -2:  # Turn left
                direction = (direction - 1) % 4
            else:
                dx, dy = directions[direction]
                for _ in range(c):
                    if (x + dx, y + dy) in obstacles:
                        break
                    x += dx
                    y += dy
                    max_distance = max(max_distance, x ** 2 + y ** 2)
        
        return max_distance