When you need to look up a mapping, like a number mapped to its source, use a hash.

use strict;
use warnings;

# Just generating data here.
my @rep1 = (1..5);
my @rep2 = (6..10);
my @rep3 = (11..15);

my @pairs = map {sprintf "%d %d", int(rand(15)+1), int(rand(15)+1)} 1.
+.10;

# Here's the magic, fairly information-dense.
# Make a list of name-array associations, pass it to map
# Then go through the members of the array and associate each member
# with the name.
my %sources = map {
    my ($name, $ref) = @$_;
    map {($_ => $name)} @$ref;
} ([rep1 => \@rep1], [rep2 => \@rep2], [rep3 => \@rep3]);

# Now, when you have a number $n1, its source is $sources{$n1}
my (@locations, @new_gp);
for (@pairs) {
    print "$_: ";
    my ($n1, $n2) = split;
    push @new_gp, $n1, $n2;
    push @locations, @sources{$n1, $n2};
    print "$n1 came from $sources{$n1}; $n2 came from $sources{$n2}\n"
+;
}
[download]

#! /usr/bin/perl

use strict;
use warnings;
use Data::Dumper;

# your pairs
my @pairs = ([1,2],[3,4],[5,6]);

# sources
my @array1 = (1,5);
my @array2 = (3,6);
my @array3 = (2,4);

my @locations;

for my $pair(@pairs){
  my @loc_array;
  for my $item(@$pair){
    my $location;
    if(grep{$_ == $item}@array1){
       $location = "array1";
    }
    elsif(grep{$_ == $item}@array2){
       $location = "array2";
    }
    else{
       $location = "array3";
    }
    push(@loc_array,$location);
  }
  push(@locations,\@loc_array);
}
[download]

Starting with sample data like what was suggested in an earlier reply:

# some sample data:
my @rep1_pids = (1..10);
my @rep2_pids = (11..20);
my @rep3_pids = (21..30);
my @pairs = ( "11\t5", "22\t14", "4\t8", "1\t29" );

# organize sources into HoH (%arrayhash):
# create %hashbuilder first, to assign source names to arrays
 
my %hashbuilder = ( rep1 => \@rep1_pids,
                    rep2 => \@rep2_pids,
                    rep3 => \@rep3_pids,
                   );

# for each source, array names will be the primary hash keys,
# and the array values will become keys of the secondary hashes:

my %arrayhash;
for my $src ( keys %hashbuilder ) {
    $arrayhash{$src}{$_} = 1 for ( @{$hashbuilder{$src}} );
}

# now identify sources for the members (items) in each pair:

for my $pairstr ( @pairs ) {
    my $srcs = '';
    for my $item ( split( /\t/, $pairstr )) {
        for my $src ( sort keys %arrayhash ) {
            if ( $arrayhash{$src}{$item} ) {
                $srcs .= "$item is from $src; ";
            }
        }
    }
    print $srcs, "\n";
}
[download]

Actually, there was a lot in the OP code that looked pretty strange and unclear; like, if the array of pairs is a set of strings like "1304\t1509", what do you think you're accomplishing with the first couple lines of the "foreach $pair" loop? And what's the purpose of the "@location" array? (You never seem to use it after pushing stuff into it.) And so on.

Let me suggest that when you write code, you start by documenting the plan for what the code is supposed to do: what its inputs and outputs should be, and (in terms understandable to an intelligent person) what the steps are that transform the input into the output. Then write the code to satisfy that description. If you have trouble writing the code, consider changing the description and trying again; if it seems too complicated to describe effectively, break it up into chunks that are easier to describe separately (those chunks become subroutines or modules).

My point is, if you can't describe the steps your code is supposed to be going through, it's likely to end up being a mess.