The basic intention behind using Short-circuiting in any coding language is to reduce the number of computations done during comparison operations. And in solidity, reduced computations means reduced gas.

Consider the following contracts:

contract shortCircuit1 {
    bool flag;

    function conditions(int x) external {
        bool isEven = x % 2 == 0;  // computation 1
        bool isNotZero = x != 0;   // computation 2

        if (isEven && isNotZero) { // computation 3
            flag = true;
        } else {
            flag = false;
        }
    }
}


contract shortCircuit2 {
    bool flag;

    function conditions(int x) external {

        if (x % 2 == 0 && x != 0) { // 3 computations only if x % 2 == 0 is true, else only 1 computation
            flag = true;
        } else {
            flag = false;
        }
    }
}

Both the contracts follow same conditions, input to function should be even and greater than 0. If the conditions are true, then the state variable flag is set to true. And if previous function call made flag true and the next call do not satisfy both conditions then flag is set to false.
Now let's just focus on the conditions written inside the functions.

shortCircuit1
function input - 0
computes both the conditions and then performs 3rd computation to checks if both conditions are true.

shortCircuit2
function input - 0
computes second condition only if first condition is true (short-circuit). Hence saving the cost of computation.

Note:- The difference in gas is very less for the examples given above. Imagine a lengthy comparison computation (say a string or array), in such cases the gas difference will be significant.