------
## 最终结论
To solve the problem of finding three indices \(i\), \(j\), and \(k\) in a permutation such that \(1 \le i < j < k \le n\) and \(p_i < p_j > p_k\), we can follow a straightforward approach. We iterate through each permutation and check for any peak pattern, where a peak is defined as an element being greater than its immediate neighbors.

Here's the step-by-step Python code to achieve this:

```python
def solve():
    import sys
    input = sys.stdin.read
    data = input().split()
    
    index = 0
    T = int(data[index])
    index += 1
    
    results = []
    
    for _ in range(T):
        n = int(data[index])
        index += 1
        p = list(map(int, data[index:index + n]))
        index += n
        
        # Find the indices i, j, k
        found = False
        for j in range(1, n - 1):
            if p[j - 1] < p[j] > p[j + 1]:
                results.append(f"YES\n{j} {j + 1} {j + 2}")
                found = True
                break
        
        if not found:
            results.append("NO")
    
    print("\n".join(results))

```

### Explanation:

1. **Input Reading**: We read all inputs at once using `sys.stdin.read()` for efficiency, especially since there can be up to 200 test cases.

2. **Iterating Over Test Cases**: For each test case, we read the size of the permutation `n` and then the permutation itself.

3. **Finding Peaks**:
   - We iterate over possible middle elements `p[j]` (from index `1` to `n-2`) because these are the only positions where a peak can occur.
   - For each position `j`, we check if it forms a peak with its neighbors: `p[j-1] < p[j] > p[j+1]`.
   - If a peak is found, we append "YES" followed by the indices (converted to 1-based) to our results.

4. **Output Results**: After processing all test cases, we output the results for each one. If no peaks are found in a test case, we output "NO".

This solution efficiently checks each permutation for the required condition and handles multiple test cases as specified.